it-swarm.dev

Gibt es aussprechbare Namen für gängige Haskell-Operatoren?

Ich lese Learn You a Haskell for Great Good , und ich kann die Haskell-Operatoren nie aussprechen. Haben sie "echte" Namen? ?

Wie liest man zum Beispiel einen solchen Ausdruck vor?

Just (+3) <*> Just 9

Ich weiß das >>= ist "binden", aber was ist mit den anderen? Da Google nicht-alphanumerische Zeichen nicht berücksichtigt, ist es schwierig, eine effiziente Suche durchzuführen ...

Ich weiß, dass Sie Ihre eigenen Operatoren erstellen können, daher können natürlich nicht alle Operatoren Namen haben, aber ich gehe davon aus, dass die allgemeinen (z. B. die in Applicative oder Monad definierten) Namen haben müssen. .

195
Thomas Levesque

So spreche ich sie aus:

 >> = binde 
 >> dann 
 *> dann 
 -> an a -> b: a nach b
 <- binden (wie es zu >> = desugars ist)
 <$> (f) Karte 
 <$ Karte-Ersetzen durch 0 <$ f: "f map-durch 0 ersetzen"
 <*> ap (ply) (da es dasselbe ist wie Control.Monad.ap)(keine, nur als "" [Leerzeichen])
. Rohr zu ein . b: "b pipe-to a"
 !! Index
! Index/streng ein ! b: "a index b", foo! x: foo strict x
 <|> oder/Alternative ausdruck <|>: "Ausdruck oder Ausdruck"
 ++ concat/plus/append 
 [] leere Liste 
: cons 
 :: vom Typ/as f x :: Int: f x vom Typ Int
\lambda 
 @ as go ll @ (l: ls): go ll as l cons ls
 ~ faul go ~ (a, b): gehe faul Paar a, b
186
fuz
| sym  | pronunciation                                    |
|------|--------------------------------------------------|
| |    | "such that"                                      |
| <-   | "is drawn from"                                  |
| =    | "is defined to be" / "is defined as"             |
| ::   | "has type" / "of type" / "is of type"            |
| ->   | "a function that takes ... and returns a ..." /  |
|      |                          "function that maps" /  |
|      |                          "is a function from" /  |
|      |                                          "to"    |
| $    | "apply"                                          |
| _    | "whatever"                                       |
| !!   | "index"                                          |
| ++   | "concat"                                         |
| []   | "empty list"                                     |
| :    | "cons"                                           |
| \    | "lambda"                                         |
| =>   | "implies" / "then"                               |
| *>   | "then"                                           |
| <$>  | "fmap" / "dollar cyclops"                        |
| <$   | "map-replace by"                                 |
| <*>  | "ap" / "star cyclops"                            |
| .    | "pipe to" / "compose" / "dot"                    |
| <|>  | "or"                                             |
| @    | "as"                                             |
| ~    | "lazy"                                           |
| <=<  | "left fish"                                      |
39
Bob Ueland

Meine persönlichen Favoriten sind "linker Fisch" (<= <) und "rechter Fisch" (> =>) . Welches sind nur die links und rechts Kleisli Zusammensetzung der Monadenoperatoren. Verfassen Sie fischig, verfassen Sie!

28

Ich habe mir die Freiheit genommen, die Antworten in einem sehr einfachen Hashell-Programm zusammenzustellen, das nur durch Pattern Matching versucht, Hashell-Code ins Englische zu übersetzen. Ich nenne es letterator, weil es Symbole in Buchstaben übersetzt

-- letterator

main = translateLn <$> getLine >>= putStrLn

translateLn :: String -> String
translateLn = unwords . map t . words

t :: String -> String -- t(ranslate)

-- historical accurate naming
t "=" = "is equal too" -- The Whetstone of Witte - Robert Recorde (1557)

-- proposed namings
-- src http://stackoverflow.com/a/7747115/1091457
t ">>=" = "bind"
t "*>"  = "then"
t "->"  = "to"                   -- a -> b: a to b
t "<$"  = "map-replace by"       --  0 <$ f: "f map-replace by 0"
t "<*>" = "ap(ply)"              --  (as it is the same as Control.Monad.ap)
t "!!"  = "index"
t "!"   = "index/strict"         --  a ! b: "a index b", foo !x: foo strict x
t "<|>" = "or/alternative"       -- expr <|> term: "expr or term"
t "[]"  = "empty list"
t ":"   = "cons"
t "\\"  = "lambda"
t "@"   = "as"                   -- go [email protected](l:ls): go ll as l cons ls
t "~"   = "lazy"                 -- go ~(a,b): go lazy pair a, b
-- t ">>"  = "then"
-- t "<-"  = "bind"              -- (as it desugars to >>=)
-- t "<$>" = "(f)map"
-- t "$"   = ""                  -- (none, just as " " [whitespace])
-- t "."   = "pipe to"           -- a . b: "b pipe-to a"
-- t "++"  = "concat/plus/append" 
-- t "::"  = "ofType/as"         -- f x :: Int: f x of type Int

-- additional names
-- src http://stackoverflow.com/a/16801782/1091457
t "|"   = "such that"
t "<-"  = "is drawn from"
t "::"  = "is of type" 
t "_"   = "whatever"
t "++"  = "append"
t "=>"  = "implies"
t "."   = "compose"
t "<=<" = "left fish"
-- t "="   = "is defined as"
-- t "<$>" = "(f)map"

-- src http://stackoverflow.com/a/7747149/1091457
t "$"   = "of" 

-- src http://stackoverflow.com/questions/28471898/colloquial-terms-for-haskell-operators-e-g?noredirect=1&lq=1#comment45268311_28471898
t ">>"  = "sequence"
-- t "<$>" = "infix fmap"
-- t ">>=" = "bind"

--------------
-- Examples --
--------------

-- "(:) <$> Just 3 <*> Just [4]" 
-- meaning "Cons applied to just three applied to just list with one element four"
t "(:)"  = "Cons"
t "Just" = "just"
t "<$>"  = "applied to"
t "3"    = "three" -- this is might go a bit too far
t "[4]"  = "list with one element four" -- this one too, let's just see where this gets us

-- additional expressions to translate from
-- src http://stackoverflow.com/a/21322952/1091457
-- delete (0, 0) $ (,) <$> [-1..1] <*> [-1..1]
-- (,) <$> [-1..1] <*> [-1..1] & delete (0, 0)
-- liftA2 (,) [-1..1] [-1..1] & delete (0, 0)
t "(,)" = "Tuple constructor"
t "&" = "then" -- flipped `$`

-- everything not matched until this point stays at it is
t x = x
8
davidDavidson
+      plus
-      minus (OR negative OR negate for unary use)
*      multiply OR times
/      divide
.      dot OR compose
$      apply OR of
4
Thomas Eding