Lepší zápis symetrické binární operace

[Vietnamka]

V jakém jazyku se nejlépe zapíše takováhle operace ? Coconut, Crystal, Rust, Julia,Lisp-Like,dart,Go,R , ? Fortran,C ,Pascal, javascript?
X=["https://",'eyy}~7""'];
(X[0].split("").chars.zip(X[1].chars.split("")))
 .map( (x,y) =>
    x.ord ^ y.ord
 )
.join

dvakrát se tam opakují tři stejné operace. Takže akadamické řešení vyžaduje ty tři operace zmínit jen jednou

Představuju si něco takovéhleho:

BinaryOperatorFactory(X.map ( _.split.chars) , &:^ , _.ord)

(to podržítko je detail -shorthand pro lambdu funkci s jednim parametrem _.ord() =  (arg)=>arg.ord())
Jasně, mohu si to napsat v pomalu každým nepřeškrtlým jazyku výše, ale ,který to umí rovnou a případně jakou k tomu volí syntaxi? Pro inspiraci
Není problém třeba
[1000,200,300].reduce(0.5, &:+) = 1230.5 a [10,20,2].reduce(3, &:*) = 1200
Ale který jazyk umí  u zápisu lambda funkcí s jediným argumentem místo map((e)=>fn(e) zkratku map (fn(_) ) ?

[Reklama]

[Vít Šesták (v6ak)]

1. Symetrická operace – nabízí se použít funkci map na vstupním poli. Jenže pokud bude na vstupu tuple, bude to horší – nevím o tom, že by nějaký staticky typovaný jazyk měl funkci map pro tuple. I když v principu (zejména pro homogenní tuple) by to šlo.
V neposlední řadě tu sice je princip DRY, ale na druhou stranu, mít na spoustu takových věcí funkci, kterou využiju jednou za uherský rok, nemusí být lepší cesta. Po tom uherském roce si musíte vybavit/vyhledat název té funkce, a při čtení může být podobný problém s exotickou funkcí.
Takže to _.split("").chars bych si možná maximálně extrahoval do nějaké funkce, zejména pokud by tam bylo něco delšího.

2. Podtržítko pro lambdu – něco takového umí Scala, i když to tuším je stále jen partial application, ne plnohodnotná lambda.

[vcunat]

Já bych takové věci asi psal v Haskellu.  Ten "join" má být... součet?  No pro ilustraci:

Kód: [Vybrat]

import Data.Char

foo str1 str2 = foldl (+) 0 $ zipWith (^) (map ord str1) (map ord str2)

Anebo tedy zobecnění

Kód: [Vybrat]

binaryOperatorFactory joinop binop unop list1 list2 =
    foldl1 joinop $ zipWith binop (map unop list1) (map unop list2)

foo = binaryOperatorFactory (+) (^) ord


[Vít Šesták (v6ak)]

Tak jsem se ještě díval, a vypadá to, že Scala 3 metodu map pro Tuple2 má: https://www.scala-lang.org/api/current/scala/Tuple2.html#map-fffff3e7

Tuple2 je tuple o dvou prvcích. Ten zápis typu na první pohled vypadá šíleně, nicméně je to patrně kvůli univerzálnosti. V jednoduchém případě, kde všechny (oba) prvky tuple mají stejný typ, to bude fungovat intuitivně. Ono by to IIUC mělo dobře fungovat i na heterogenní tuple, kde chcete například všechny prvky obalit do Future. Možná dokonce i vybalení prvků půjde.

[registrovany_ava]

Já bych si v zájmu čitelnosti a jednoduchosti napsal na ten opakující se kus kódu lokální funkci (tím, že ji pojmenuji a není anonymní zároveň usnadňuji čtení) a udělal bych něco jako (pseudokód/mix jazyků)

fn stringBytes(s: String) -> Iterator<Byte> { s.split("").chars().map(c => c.ord) }

stringBytes(X[0]).zip(stringBytes(X[1])).map((x, y) => x ^ y).join()

[Reklama]

[listoper]

Nevim jestli sem pochopil zadani, ale tak zkusim clojure...

Kód: [Vybrat]

  (def x ["https://" "eyy}~7\"\""])
  (reduce + (apply map #(bit-xor (int %1) (int %2)) x))


[RDa]

Cece, ja ti nevim, ale tyhle frikulinske syntaxe a divnojazyky fakt nedavam. Kdybych necetl zadani, tak podle tech uvedenych vzorku bych nikdy nepochopil co to vlastne ma jako delat.

Zlate starodavni a primitivni C.

Jaky smysl ma pouzivat neco, co neni mainstream, nikto tomu nerozumi, aplikovatelnost je mizerna protoze potrebujete runtime nebo compiler, ktery v dane architekture x distribuci x releasu proste nebude.. to uz mam omnoho vetsi pochopeni pro Cobol, nez tady ty random nudle se speky.

[mark42]

Cece, ja ti nevim, ale tyhle frikulinske syntaxe a divnojazyky fakt nedavam. Kdybych necetl zadani, tak podle tech uvedenych vzorku bych nikdy nepochopil co to vlastne ma jako delat.
Zlate starodavni a primitivni C.

Podobne z navrhovanych rieseni to asi najlepsie dava Haskell. Ale na ten potrebuje clovek uplne inak nastavit mozog ako na C.

[Vít Šesták (v6ak)]

Zkusil jsem to napsat ve Scale. Z nějakého důvodu jsem neuspěl s map u tuple, a snad jsem pochopil, co úvodní kód měl dělat:

Kód: [Vybrat]

val url = "https://"                                                                                                                           
val key = "eyy}~\"\""
def intize(s: String) = s.map(_.toInt)
intize(url).zip(intize(key)).map(_^_).map(_.toChar).mkString


[echo_zulu]

Cece, ja ti nevim, ale tyhle frikulinske syntaxe a divnojazyky fakt nedavam. Kdybych necetl zadani, tak podle tech uvedenych vzorku bych nikdy nepochopil co to vlastne ma jako delat.

Zlate starodavni a primitivni C.

Jaky smysl ma pouzivat neco, co neni mainstream, nikto tomu nerozumi, aplikovatelnost je mizerna protoze potrebujete runtime nebo compiler, ktery v dane architekture x distribuci x releasu proste nebude.. to uz mam omnoho vetsi pochopeni pro Cobol, nez tady ty random nudle se speky.

Čeče, ja vám neviem, ale nad vašou poznámkou by Shoenfinkel, Curry a Church asi iba krútili hlavou, lebo oni o aparáte, na ktorom toto stojí, písali dávno pred tým ako bolo nejaké céčko. Takže je celkom otázka, čo je vlastne frikulínske.

Ale to neznamená, že vaše pocity nechápem, tiež som na to pozeral ako na zjavenie, keď som sa tým prvýkrát stretol a kým som pochopil, že to jednoducho potrebujem.