learnxinyminutes-docs/dhall.html.markdown
Profpatsch ec3d3f91ea [dhall/de]: add German translation (#3600)
* [dhall/en] Typo & highlight terms

Template and package are referencing concepts from other languages, so
let’s highlight them to clarify.

* [dhall/de] Translate to German

The translation leaves (most) of the code as-is, only changing the
comments and some string contents.

The `philadelphia` and `john` fields are changed to `augsburg` and
`bernd` respectively, as an in-joke for German programmers.
2019-08-19 18:27:50 +05:30

363 lines
12 KiB
Markdown

---
language: Dhall
filename: learndhall.dhall
contributors:
- ["Gabriel Gonzalez", "http://www.haskellforall.com/"]
---
Dhall is a programmable configuration language that provides a non-repetitive
alternative to YAML.
You can think of Dhall as: JSON + functions + types + imports
Note that while Dhall is programmable, Dhall is not Turing-complete. Many
of Dhall's features take advantage of this restriction to provide stronger
safety guarantees and more powerful tooling.
```haskell
-- Single-line comment
{- Multi-line comment
Unicode is fine 🙂
This file is a valid Dhall expression that evaluates to a large record
collecting the results of each step.
You can view the results by interpreting the file:
$ dhall --file learndhall.dhall
{- Comments can be nested -}
-}
let greeting = "Hello, world!"
let fruits = "🍋🍓🍍🍉🍌"
let interpolation = "Enjoy some delicious fruit: ${fruits}"
let multilineText {- Inline comments work, too -} =
''
Leading whitespace is stripped from multi-line text literals.
That means you can freely indent or dedent a text literal without
changing the result.
Relative indentation within the literal is still preserved.
Other than that, the text literal is preserved verbatim, similar to a
"literal" YAML multiline string.
''
let bool = True
-- Type annotations on bindings are optional, but helpful, so we'll use them
let annotation : Bool = True
let renderedBool : Text = if bool then "True" else "False"
-- Natural numbers are non-negative and are unsigned
let naturalNumber : Natural = 42
-- Integers may be negative, but require an explicit sign, even if positive
let positiveInteger : Integer = +1
let negativeInteger : Integer = -12
let pi : Double = 3.14159265359
{- You can use a wider character range for identifiers (such as quotation
marks and whitespace) if you quote them using backticks
-}
let `Avogadro's Number` : Double = 6.0221409e+23
let origin : { x : Double, y : Double } = { x = 0.0, y = 0.0 }
let somePrimes : List Natural = [ 2, 3, 5, 7, 11 ]
{- A schema is the same thing as a type
Types begin with an uppercase letter by convention, but this convention is
not enforced
-}
let Profile : Type
= { person :
{ name : Text
, age : Natural
}
, address :
{ country : Text
, state : Text
, city : Text
}
}
let john : Profile =
{ person =
{ name = "John Doe"
, age = 67
}
, address =
{ country = "United States"
, state = "Pennsylvania"
, city = "Philadelphia"
}
}
let philadelphia : Text = john.address.city
{- Enum alternatives also begin with an uppercase letter by convention. This
convention is not enforced
-}
let DNA : Type = < Adenine | Cytosine | Guanine | Thymine >
let dnaSequence : List DNA = [ DNA.Thymine, DNA.Guanine, DNA.Guanine ]
let compactDNASequence : List DNA =
let a = DNA.Adenine
let c = DNA.Cytosine
let g = DNA.Guanine
let t = DNA.Thymine
in [ c, t, t, a, t, c, g, g, c ]
-- You can transform enums by providing a record with one field per alternative
let theLetterG : Text =
merge
{ Adenine = "A"
, Cytosine = "C"
, Guanine = "G"
, Thymine = "T"
}
DNA.Guanine
let presentOptionalValue : Optional Natural = Some 1
let absentOptionalValue : Optional Natural = None Natural
let points : List { x : Double, y : Double } =
[ { x = 1.1, y = -4.2 }
, { x = 4.4, y = -3.0 }
, { x = 8.2, y = -5.5 }
]
{- `Natural -> List Natural` is the type of a function whose input type is a
`Natural` and whose output type is a `List Natural`
All functions in Dhall are anonymous functions (a.k.a. "lambdas"),
which you can optionally give a name
For example, the following function is equivalent to this Python code:
lambda n : [ n, n + 1 ]
... and this JavaScript code:
function (n) { return [ n, n + 1 ]; }
-}
let exampleFunction : Natural -> List Natural =
\(n : Natural) -> [ n, n + 1 ]
-- Dhall also supports Unicode syntax, but this tutorial will stick to ASCII
let unicodeFunction : Natural List Natural =
λ(n : Natural) [ n, n + 1 ]
-- You don't need to parenthesize function arguments
let exampleFunctionApplication : List Natural =
exampleFunction 2
let functionOfMultipleArguments : Natural -> Natural -> List Natural =
\(x : Natural) -> \(y : Natural) -> [ x, y ]
let functionAppliedToMultipleArguments : List Natural =
functionOfMultipleArguments 2 3
{- Same as `exampleFunction` except we gave the function's input type a
name: "n"
-}
let namedArgumentType : forall (n : Natural) -> List Natural =
\(n : Natural) -> [ n, n + 1 ]
{- If you name a function's input type, you can use that name later within the
same type
This lets you write a function that works for more than one type of input
(a.k.a. a "polymorphic" function)
-}
let duplicate : forall (a : Type) -> a -> List a =
\(a : Type) -> \(x : a) -> [ x, x ]
let duplicatedNumber : List Natural =
duplicate Natural 2
let duplicatedBool : List Bool =
duplicate Bool False
{- The language also has some built-in polymorphic functions, such as:
List/head : forall (a : Type) -> List a -> Optional a
-}
let firstPrime : Optional Natural = List/head Natural somePrimes
let functionOfARecord : { x : Natural, y : Natural } -> List Natural =
\(args : { x : Natural, y : Natural }) -> [ args.x, args.y ]
let functionAppliedToARecord : List Natural =
functionOfARecord { x = 2, y = 5 }
{- All type conversions are explicit
`Natural/show` is a built-in function of the following type:
Natural/show : Natural -> Text
... that converts `Natural` numbers to their `Text` representation
-}
let typeConversion : Natural -> Text =
\(age : Natural) -> "I am ${Natural/show age} years old!"
-- A "template" is the same thing as a function whose output type is `Text`
let mitLicense : { year : Natural, copyrightHolder : Text } -> Text =
\(args : { year : Natural, copyrightHolder : Text }) ->
''
Copyright ${Natural/show args.year} ${args.copyrightHolder}
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
''
-- Template instantiation is the same thing as function application
let templatedLicense : Text =
mitLicense { year = 2019, copyrightHolder = "Jane Smith" }
{- You can import expressions by URL
Also, like Bash, you can import code from your local filesystem (not shown)
Security-conscious users can pin remotely-imported expressions by adding a
semantic integrity check. The interpreter rejects any attempt to tamper with
an expression pinned in this way. However, behavior-preserving refactors
of imported content will not perturb the hash.
Imported expressions pinned in this way are also locally cached in a
content-addressable store (typically underneath `~/.cache/dhall`)
-}
let Natural/sum : List Natural -> Natural =
https://prelude.dhall-lang.org/Natural/sum
sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037
let twentyEight : Natural = Natural/sum somePrimes
-- A "package" is the same thing as a (possibly nested) record that you can import
let Prelude = https://prelude.dhall-lang.org/package.dhall
let false : Bool = Prelude.Bool.not True
-- You can import the raw contents of a file by adding `as Text` to an import
let sourceCode : Text = https://prelude.dhall-lang.org/Bool/not as Text
-- You can import environment variables, too:
let presentWorkingDirectory = env:PWD as Text
-- You can provide a fallback expression if an import fails
let home : Optional Text = Some env:HOME ? None Text
-- Fallback expressions can contain alternative imports of their own
let possiblyCustomPrelude =
env:DHALL_PRELUDE
? https://prelude.dhall-lang.org/package.dhall
{- Tie everything together by auto-generating configurations for 10 build users
using the `generate` function:
Prelude.List.generate
: Natural -> forall (a : Type) -> (Natural -> a) -> List a
-}
let buildUsers =
let makeUser = \(user : Text) ->
let home = "/home/${user}"
let privateKey = "${home}/.ssh/id_ed25519"
let publicKey = "${privateKey}.pub"
in { home = home
, privateKey = privateKey
, publicKey = publicKey
}
let buildUser =
\(index : Natural) -> makeUser "build${Natural/show index}"
let Config =
{ home : Text
, privateKey : Text
, publicKey : Text
}
in Prelude.List.generate 10 Config buildUser
-- Present all of the results in a final record
in { greeting = greeting
, fruits = fruits
, interpolation = interpolation
, multilineText = multilineText
, bool = bool
, annotation = annotation
, renderedBool = renderedBool
, naturalNumber = naturalNumber
, positiveInteger = positiveInteger
, negativeInteger = negativeInteger
, pi = pi
, `Avogadro's Number` = `Avogadro's Number`
, origin = origin
, somePrimes = somePrimes
, john = john
, philadelphia = philadelphia
, dnaSequence = dnaSequence
, compactDNASequence = compactDNASequence
, theLetterG = theLetterG
, presentOptionalValue = presentOptionalValue
, absentOptionalValue = absentOptionalValue
, points = points
, exampleFunction = exampleFunction
, unicodeFunction = unicodeFunction
, exampleFunctionApplication = exampleFunctionApplication
, functionOfMultipleArguments = functionOfMultipleArguments
, functionAppliedToMultipleArguments = functionAppliedToMultipleArguments
, namedArgumentType = namedArgumentType
, duplicate = duplicate
, duplicatedNumber = duplicatedNumber
, duplicatedBool = duplicatedBool
, firstPrime = firstPrime
, functionOfARecord = functionOfARecord
, functionAppliedToARecord = functionAppliedToARecord
, typeConversion = typeConversion
, mitLicense = mitLicense
, templatedLicense = templatedLicense
, twentyEight = twentyEight
, false = false
, sourceCode = sourceCode
, presentWorkingDirectory = presentWorkingDirectory
, home = home
, buildUsers = buildUsers
}
```
To learn more, visit the official website, which also lets you try the
language live in your browser:
* [https://dhall-lang.org](http://dhall-lang.org/)