Über Haskell-Namen

    Der Name eines Bezeichners in Haskell beginnt mit einem Buchstaben, gefolgt von
    null oder mehr Buchstaben, Zahlen, Unterstrichen _ und dem einfachen Anführungszeichen '. Als Buchstaben gelten nur lateinische Zeichen in den Intervallen a..z und A..Z. Das _-Symbol wird als Buchstabe betrachtet , weshalb der Funktionsname mit diesem Symbol beginnen kann, aber nicht nur daraus bestehen kann, da er in Haskell- Beispielen einen beliebigen Wert angibt . Namen von Funktionen , nicht von ascSymbol Zeichensatz zusammengesetzt, unbedingt muss mit einem Kleinbuchstabe oder ein Symbol beginnen _. Namespace-Namen, Datentypen, Datenkonstruktoren und TypklassenNicht aufsteigende Zeichen müssen mit einem Großbuchstaben beginnen. Dieser Hinweis enthält einige Informationen zur Verwendung von ascSymbol-Zeichen in Haskell-Bezeichnern.

    Sonderzeichen


    Gemäß § 2.2 des Haskell 2010-Standards gelten die folgenden Zeichen als Sonderzeichen: Der folgende Zeichensatz mit dem Namen ascSymbol wird ebenfalls separat definiert: Alphanumerische Zeichen im Standard werden in separate Sätze unterteilt: ascSmall, ascLarge, uniSmall, uniLarge, ascDigit, uniDigit und etc. Manchmal werden Sonderzeichen fälschlicherweise als Zeichen bezeichnet, die Teil des ascSymbol-Satzes sind. Beispielsweise wird beim Definieren eines Operators manchmal gesagt, dass seine Namen nur aus Sonderzeichen bestehen . Tatsächlich können Sonderzeichen nicht als Teil von Bedienernamen (und in der Tat als Teil eines beliebigen Namens) verwendet werden. Aus ascSymbol-Zeichen dürfen nur die folgenden Namen gebildet werden:

    (
    )
    ,
    ;
    [
    ]
    `
    {
    }



    !
    #
    $
    %
    &
    *
    +
    .
    /
    <
    =
    >
    ?
    @
    \
    ˆ
    |
    -
    ˜
    :








    reserviert :
    ..
    :
    ::
    =
    \
    |
    <-
    ->
    @
    ~
    =>


    Funktion oder Betreiber?


    Ein Operator in Haskell ist jede Funktion, die in Form eines Infixes aufgerufen oder teilweise durch Abschnitte hindurch angewendet wird . T.O. Ob eine Funktion als Operator bezeichnet werden kann, hängt vom Kontext ihrer Verwendung ab . In den folgenden Beispielen sind Funktionen elemund *Operatoren:
    λ: 5 `elem` [0..10]
    True
    λ: 4 * 10
    40
    

    Einige benutzerdefinierte Funktionen zur Verwendung als Abschnitte:
    mySomeFunc :: Integral a => a -> a -> a
    _ `mySomeFunc` 0 = error "Zero division."
    a `mySomeFunc` b = a `div` b
    

    Wir verwenden die Funktion mySomeFuncals Abschnitte, d.h. In diesem Zusammenhang ist es ein Operator:
    λ: let n = (8 `mySomeFunc`)
    λ: let m = (`mySomeFunc` 2)
    λ: n 2
    4
    λ: m 10
    5
    

    Eine in Präfixform aufgerufene Funktion ist in diesem Anwendungskontext kein Operator . In den folgenden Beispielen funktionieren elemund sind *keine Operatoren:
    λ: elem 5 [0..10]
    True
    λ: (*) 4 10
    40


    Infix- und Präfixformulare


    Wenn der Funktionsname aus ascSymbol-Zeichen besteht, muss dieser Name bei der Angabe der Signatur in Klammern eingeschlossen werden.
    (###) :: Int -> Int -> Int -- Сигнатура функции
    

    Wenn der Name der Funktion von ascSymbol Zeichensatz besteht, und seine Definition wird in der gegebenen Präfix - Notation, wie der Name ist es notwendig , in Klammern angegeben.
    (@@@) a = (a +) -- Определение функции в префиксной форме
    

    Wenn der Funktionsname nicht aus ascSymbol-Zeichen besteht und seine Definition in der Infix- Notation angegeben ist, muss der Name mit Backtick-Zeichen `maskiert werden.
    a `myFunc` b = a * b -- Определение функции в инфиксной форме
    

    Beispiele für die Verwendung von Infix - Form und Präfix der Einträge in der Code Definition der Funktionen:
    (###) :: Int -> Int -> Int -- Сигнатура функции
    a ### b = a * b -- Определение функции в инфиксной форме
    (@@@) :: Int -> Int -> Int -- Сигнатура функции
    (@@@) a = (a +) -- Определение функции в префиксной форме
    myFunc :: Int -> Int -> Int -- Сигнатура функции
    a `myFunc` b = a * b -- Определение функции в инфиксной форме
    myFunc' :: Int -> Int -> Int -- Сигнатура функции
    myFunc' a = (a -) -- Определение функции в префиксной форме
    


    In Infix-Form können Sie jede Funktion aufrufen , deren Anzahl von Parametern mehr als eins beträgt, zum Beispiel:
    λ: ((+) `foldr` 0) [1..10]
    55

    Oder zum Beispiel eine Funktion, die vier Parameter akzeptiert:
    someFunc :: Int -> Int -> Int -> Int -> Int
    someFunc a b c d = a + b + c + d
    

    Präfix- und Infixvarianten seines Aufrufs:
    λ: someFunc 1 2 3 4
    10
    λ: (1 `someFunc` 2) 3 4
    10
    


    Datenkonstruktornamen


    Wie oben erwähnt, beginnen die Namen von Datenkonstruktoren mit einem Großbuchstaben und bestehen aus alphanumerischen Zeichen sowie den Zeichen _ und '(falls erforderlich). Es ist jedoch ein Benennungssystem zulässig, ähnlich dem
    für Funktionen ... Mit dem
    Haskell-Standard ist es möglich, Datenkonstruktornamen
    aus ascSymbol-Zeichen zu bilden. Solche Konstruktoren können wie gewöhnliche Funktionen sowohl in Infix- als auch in Präfixform verwendet werden
    . Darüber hinaus sind ihre Namen unbedingt mit einem beginnen muss: (Doppelpunkt).
    Das heißt wenn du irgendwo was im code siehst
    wie123 :#$% "ASDF"können Sie sofort sicher sein, dass Sie einen Konstruktoraufruf haben: # $% mit den Parametern
    123 und "ASDF".
    data Symbolic n
      = Constant n
       | Variable String
       | Symbolic n :=> Symbolic n
       | Symbolic n :<= Symbolic n
       | (:<=>) (Symbolic n) (Symbolic n)
      deriving Show


    Wir werden mehrere Instanzen des Typs in ghci Symbolicmit verschiedenen Datenkonstruktoren erstellen :
    λ: let a = Constant 10; b = Variable "Hello"
    λ: let n = a :=> b; m = a :<= b; k = a :<=> b
    λ: n
    Constant 10 :=> Variable "Hello"
    λ: m
    Constant 10 :<= Variable "Hello"
    λ: k
    (:<=>) (Constant 10) (Variable "Hello")


    Geben Sie Konstruktornamen ein


    Standardmäßig , Namen Typkonstruktoren können nicht von ascSymbol Zeichensatz bestehen. Sie können jedoch die Verwendung solcher Namen für Typkonstruktoren erzwingen . Dies erfolgt entweder durch Angabe der Option
    -XTypeOperators beim Aufrufen von ghc oder ghci oder durch Hinzufügen der folgenden Zeile am Anfang der hs-Datei:
    {-# LANGUAGE TypeOperators #-}

    Im Gegensatz zu einem Datenkonstruktor muss ein Typkonstruktorname nicht mit dem Zeichen beginnen: (Doppelpunkt).

    {-# LANGUAGE TypeOperators #-}
    data a @# b -- Конструктор типа
      -- Конструкторы данных:
      = XLeft a
       | XRight b
       | (a @# b) :$% (a @# b)
       | (a @# b) :!~ (a @# b)
       | (:!~>) (a @# b) (a @# b) (a @# b)
      deriving Show
    

    Wir versuchen Instanzen unseres Datentyps zu erstellen:
    λ: let a = XLeft 10; b = XRight "ABCD"
    λ: let c = a :$% b; d = b :!~ a;
    λ: let e = (:!~>) a a a
    λ: c
    XLeft 10 :$% XRight "ABCD"
    λ: d
    XRight "ABCD" :!~ XLeft 10
    λ: e
    (:!~>) (XLeft 10) (XLeft 10) (XLeft 10)
    


    Probennamen


    Die Namen der Proben können auch aus ascSymbol Zeichensatz zusammengesetzt sein.
    λ: let ($%%) = (*)
    λ: :t ($%%)
    ($%%) :: Num a => a -> a -> a
    λ: 5 $%% 2
    10
    λ: ($%%) 3 4
    12
    λ: let (###) = (3 +)
    λ: (###) 2
    5
    

    UPD-
    Funktionsnamen können mit anderen Unicode-Zeichen zugewiesen werden. Zum Beispiel kann man in Büchern manchmal Symbole von mathematischen Operatoren als Funktionsnamen finden . Sie könnten beispielsweise eine Funktion wie die folgende schreiben:
    (∀) :: (a -> b) -> [a] -> [b]
    f ∀ [] = []
    f ∀ (x:xs) = f x : f ∀ xs
    

    Diese Funktion wird erfolgreich in ghci geladen , es ist jedoch problematisch, sie aufzurufen, da es in cmd.exe und powershell.exe möglicherweise schwierig ist, das Symbol символ in die Befehlszeile einzugeben . Ich konnte dies weder über die Zwischenablage (das entsprechende Element im Kontextmenü) noch über die Tastenkombination ( Alt + 8704 ) tun . Die Verwendung der Lucida-Konsolenschrift und der Aufruf des Befehls chcp.com 65001 helfen ebenfalls nicht .

    In einigen Büchern ist jedoch eine sehr aktive Verwendung von mathematischen Symbolen als Funktionsnamen im Haskell-Quellcode zu sehen. Zum Beispiel in Richard Birds Buch„Perlen der Algorithmenentwicklung. Funktionaler Ansatz. Mit Beispielen bei Haskell . "

    Um es zusammenzufassen


    Wenn es sich nicht um Funktionen handelt, ist es unwahrscheinlich, dass Sie ascSymbol-Zeichen in Bezeichnernamen verwenden. Wenn Sie jedoch wissen, wie sie außerhalb des Bereichs von Funktionsnamen angewendet werden können, können Sie den Code besser verstehen, in dem sie aus irgendeinem Grund dennoch verwendet werden.

    Jetzt auch beliebt: