mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-18 12:52:29 +03:00
372 lines
9.7 KiB
Nix
372 lines
9.7 KiB
Nix
---
|
||
language: nix
|
||
filename: learn-sv.nix
|
||
contributors:
|
||
- ["Chris Martin", "http://chris-martin.org/"]
|
||
translators:
|
||
- ["Edward Tjörnhammar", "http://edwtjo.me"]
|
||
lang: sv-se
|
||
---
|
||
|
||
Nix är ett enkelt funktionelt språk utvecklat för
|
||
[Nix pakethanteraren](https://nixos.org/nix/) och
|
||
[NixOS](https://nixos.org/) linuxdistributionen.
|
||
|
||
Du kan utvärdera Nix uttryck genom att använda
|
||
[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
|
||
eller [`nix-repl`](https://github.com/edolstra/nix-repl).
|
||
|
||
```
|
||
with builtins; [
|
||
|
||
# Kommentarer
|
||
#=========================================
|
||
|
||
# Inlinekommentarer ser ut såhär.
|
||
|
||
/* Flerradskommentarer ser ut
|
||
såhär. */
|
||
|
||
|
||
# Booleaner
|
||
#=========================================
|
||
|
||
(true && false) # Och
|
||
#=> false
|
||
|
||
(true || false) # Eller
|
||
#=> true
|
||
|
||
(if 3 < 4 then "a" else "b") # Villkorlig
|
||
#=> "a"
|
||
|
||
|
||
# Heltal
|
||
#=========================================
|
||
|
||
# Heltal är den enda numeriska typen.
|
||
|
||
1 0 42 (-3) # Några heltal
|
||
|
||
(4 + 6 + 12 - 2) # Addition
|
||
#=> 20
|
||
|
||
(7 / 2) # Division
|
||
#=> 3
|
||
|
||
|
||
# Strängar
|
||
#=========================================
|
||
|
||
"Stränglitteraler omgärdas av raka citationstecken."
|
||
|
||
"
|
||
Stränglitteraler kan sträcka sig
|
||
över flera rader.
|
||
"
|
||
|
||
''
|
||
Detta kallas för en indenterad strängliteral, omgärdad av dubbla apostrofer
|
||
Den plockar intelligent bort ledande blanktecken.
|
||
''
|
||
|
||
''
|
||
a
|
||
b
|
||
''
|
||
#=> "a\n b"
|
||
|
||
("ab" + "cd") # Strängkonkatenering
|
||
#=> "abcd"
|
||
|
||
# Antikvotering låter dig bädda in språkvärden i strängar.
|
||
("Din hemkatalog är ${getEnv "HOME"}")
|
||
#=> "Din hemkatalog är /home/alice"
|
||
|
||
|
||
# Sökvägar
|
||
#=========================================
|
||
|
||
# Nix har en primitiv, inbyggd, typ för sökvägar.
|
||
/tmp/tutorials/learn.nix
|
||
|
||
# Relativa sökvägar förenas med sökvägen till dess definerande fils sökväg
|
||
# vid tolkningstillfället för att skapa dess absoluta sökväg.
|
||
|
||
tutorials/learn.nix
|
||
#=> /the-base-path/tutorials/learn.nix
|
||
|
||
# En sökväg måste innehålla åtminstonde ett snedstreck, så en relativ sökväg
|
||
# till en fil i samma katalog måste ges ett "./" prefix
|
||
|
||
./learn.nix
|
||
#=> /the-base-path/learn.nix
|
||
|
||
# Divisionsoperatorn / måste omges av blanksteg om man vill att det skall
|
||
# tolkas som heltalsdivision
|
||
|
||
7/2 # Detta är en sökväg
|
||
(7 / 2) # Detta är heltalsdivision
|
||
|
||
|
||
# Importer
|
||
#=========================================
|
||
|
||
# En nix fil innehåller ett enstaka topnivåuttryck utan fria variabler.
|
||
# Ett importuttryck evalueras till värdet på filen som den importerar.
|
||
(import /tmp/foo.nix)
|
||
|
||
# Importer kan också specificeras med hjälp av strängar.
|
||
(import "/tmp/foo.nix")
|
||
|
||
# Importsökvägar måste vara absoluta. Sökvägslitteraler härleds vid
|
||
# tolkningstillfället så följande är ok.
|
||
(import ./foo.nix)
|
||
|
||
# Men detta är inte något som sker med strängar.
|
||
(import "./foo.nix")
|
||
#=> error: string ‘foo.nix’ doesn't represent an absolute path
|
||
|
||
|
||
# Let
|
||
#=========================================
|
||
|
||
# `let` block tillåter oss att binda värden till namn.
|
||
(let x = "a"; in
|
||
x + x + x)
|
||
#=> "aaa"
|
||
|
||
# Bindingar kan referera till varandra och deras ordning sinsemellan spelar
|
||
# ingen roll.
|
||
(let y = x + "b";
|
||
x = "a"; in
|
||
y + "c")
|
||
#=> "abc"
|
||
|
||
# Innre bindningar skuggar utanpåliggande bindingar.
|
||
(let a = 1; in
|
||
let a = 2; in
|
||
a)
|
||
#=> 2
|
||
|
||
|
||
# Funktioner
|
||
#=========================================
|
||
|
||
(n: n + 1) # En lambdafunktion som lägger till 1
|
||
|
||
((n: n + 1) 5) # Samma funktion applicerad på 5
|
||
#=> 6
|
||
|
||
# Det finns ingen syntax för direkt namngivna funktioner, istället binder man
|
||
# dessa med `let` block som andra värden.
|
||
(let succ = (n: n + 1); in succ 5)
|
||
#=> 6
|
||
|
||
# En funktion är en lambda med en parameter. Flera parameterar kan ges med
|
||
# hjälp av currying.
|
||
((x: y: x + "-" + y) "a" "b")
|
||
#=> "a-b"
|
||
|
||
# Vi kan också ha namngivna funktionsparametrar, vilket vi kommer komma till
|
||
# senare, efter att vi introducerat attributset.
|
||
|
||
# Listor
|
||
#=========================================
|
||
|
||
# Listor noteras med hakparenteser.
|
||
|
||
(length [1 2 3 "x"])
|
||
#=> 4
|
||
|
||
([1 2 3] ++ [4 5])
|
||
#=> [1 2 3 4 5]
|
||
|
||
(concatLists [[1 2] [3 4] [5]])
|
||
#=> [1 2 3 4 5]
|
||
|
||
(head [1 2 3])
|
||
#=> 1
|
||
(tail [1 2 3])
|
||
#=> [2 3]
|
||
|
||
(elemAt ["a" "b" "c" "d"] 2)
|
||
#=> "c"
|
||
|
||
(elem 2 [1 2 3])
|
||
#=> true
|
||
(elem 5 [1 2 3])
|
||
#=> false
|
||
|
||
(filter (n: n < 3) [1 2 3 4])
|
||
#=> [ 1 2 ]
|
||
|
||
|
||
# Mängder
|
||
#=========================================
|
||
|
||
# Ett attributset är en oordnad mappning av strängnycklar och värden.
|
||
{ foo = [1 2]; bar = "x"; }
|
||
|
||
# Punktoperatorn . väljer ett värde från attributset:et
|
||
{ a = 1; b = 2; }.a
|
||
#=> 1
|
||
|
||
# Frågeoperatorn ? testar om en nyckel är närvarande i ett attributset
|
||
({ a = 1; b = 2; } ? a)
|
||
#=> true
|
||
({ a = 1; b = 2; } ? c)
|
||
#=> false
|
||
|
||
# Snedstrecksoperatorn // slår ihop två attributset:ar.
|
||
({ a = 1; } // { b = 2; })
|
||
#=> { a = 1; b = 2; }
|
||
|
||
# Värden på höger skriver över värden till vänster.
|
||
({ a = 1; b = 2; } // { a = 3; c = 4; })
|
||
#=> { a = 3; b = 2; c = 4; }
|
||
|
||
# Recursionsnyckelordet rec noterar ett rekursivt attributset (en fixpunkt)
|
||
# i vilket attributen kan referera till varandra.
|
||
(let a = 1; in { a = 2; b = a; }.b)
|
||
#=> 1
|
||
(let a = 1; in rec { a = 2; b = a; }.b)
|
||
#=> 2
|
||
|
||
# Nästlade attributset:ar kan definieras bit för bit.
|
||
{
|
||
a.b = 1;
|
||
a.c.d = 2;
|
||
a.c.e = 3;
|
||
}.a.c
|
||
#=> { d = 2; e = 3; }
|
||
|
||
# Ett attributsets barn kan inte tilldelas på detta vis om attributsetet
|
||
# självt blivit direkt tilldelat.
|
||
{
|
||
a = { b = 1; };
|
||
a.c = 2;
|
||
}
|
||
#=> error: attribute ‘a’ already defined
|
||
|
||
|
||
# Bindningsintroduktion, `with`
|
||
#=========================================
|
||
|
||
# Det attributset vilket återfinns i ett `with` uttryck kommer få sina
|
||
# värdebindningar introducerade i efterkommande uttryck.
|
||
(with { a = 1; b = 2; };
|
||
a + b)
|
||
# => 3
|
||
|
||
# Innre bindningar skuggar yttre bindningar.
|
||
(with { a = 1; b = 2; };
|
||
(with { a = 5; };
|
||
a + b))
|
||
#=> 7
|
||
|
||
# Första raden av detta exempel börjar med "with builtins;" eftersom builtins
|
||
# är ett attributset innehållande alla inbyggda hjälpfunktioner såsom
|
||
# (length, head, tail, filter, etc.). Detta sparar oss från att hela tiden
|
||
# referera in i det attributset:et , alltså du kan använda bara "length"
|
||
# istället för "builtins.length".
|
||
|
||
|
||
# Attributsetmönster
|
||
#=========================================
|
||
|
||
# Attributset är användbara när vi skall skicka med flera värden till en
|
||
# funktion.
|
||
(args: args.x + "-" + args.y) { x = "a"; y = "b"; }
|
||
#=> "a-b"
|
||
|
||
# Man kan använda attributsetmönster för ökad tydlighet.
|
||
({x, y}: x + "-" + y) { x = "a"; y = "b"; }
|
||
#=> "a-b"
|
||
|
||
# Attributmönster misslyckas dock om det medskickade attributmönstret
|
||
# innehåller extra nycklar.
|
||
({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
|
||
#=> error: anonymous function called with unexpected argument ‘z’
|
||
|
||
# Genom att lägga till ", ..." kan vi ignorera ytterliggare nycklar.
|
||
({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
|
||
#=> "a-b"
|
||
|
||
|
||
# Felmeddelanden
|
||
#=========================================
|
||
|
||
# `throw` gör att programtolken gör abort med dess tillhörande felmeddelande
|
||
causes evaluation to abort with an error message.
|
||
(2 + (throw "foo"))
|
||
#=> error: foo
|
||
|
||
# `tryEval` fångar kastade fel `throw`.
|
||
(tryEval 42)
|
||
#=> { success = true; value = 42; }
|
||
(tryEval (2 + (throw "foo")))
|
||
#=> { success = false; value = false; }
|
||
|
||
# `abort` fungerar som `throw`, men är kritiskt och kan inte fångas.
|
||
(tryEval (abort "foo"))
|
||
#=> error: evaluation aborted with the following error message: ‘foo’
|
||
|
||
# `assert` utvärderas till det givna värdet om dess predikat är sant.
|
||
# annars skickar den ett fångbart fel.
|
||
(assert 1 < 2; 42)
|
||
#=> 42
|
||
(assert 1 > 2; 42)
|
||
#=> error: assertion failed at (string):1:1
|
||
(tryEval (assert 1 > 2; 42))
|
||
#=> { success = false; value = false; }
|
||
|
||
|
||
# Orenhet
|
||
#=========================================
|
||
|
||
# Eftersom repeterbarhet för byggen är en kritisk egenskap för
|
||
# Nix-pakethanteraren betonas funktionell renhet i Nix-programmeringsspråket.
|
||
# Men med det sagt existerar det källor till orenhet
|
||
|
||
# Man kan referera till miljövariabler.
|
||
(getEnv "HOME")
|
||
#=> "/home/alice"
|
||
|
||
# `trace` funktionen används för att debugga. Den skriver ut första argumentet
|
||
# till stderr och reduceras samtidigt till det andra argumentet.
|
||
(trace 1 2)
|
||
#=> trace: 1
|
||
#=> 2
|
||
|
||
# Man kan skriva filer till Nix-store, lagringsplatsen för alla Nix-uttryck.
|
||
# Även om detta är orent beteende är det hyfsat säkert eftersom filens
|
||
# lagringsplats är härledd från dess innehåll och beroenden. Man kan läsa
|
||
# filer från precis överallt. I nedanstående exempel skriver vi en fil till
|
||
# Nix-store och sedan läser tillbaka den.
|
||
|
||
(let filename = toFile "foo.txt" "hello!"; in
|
||
[filename (builtins.readFile filename)])
|
||
#=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
|
||
|
||
# Vi kan också ladda ned filer till Nix-store.
|
||
(fetchurl "https://example.com/package-1.2.3.tgz")
|
||
#=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz"
|
||
|
||
]
|
||
```
|
||
|
||
### Vidare Läsning (eng)
|
||
|
||
* [Nix Manual - Nix expression language]
|
||
(https://nixos.org/nix/manual/#ch-expression-language)
|
||
|
||
* [James Fisher - Nix by example - Part 1: The Nix expression language]
|
||
(https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
|
||
|
||
* [Susan Potter - Nix Cookbook - Nix By Example]
|
||
(https://ops.functionalalgebra.com/nix-by-example/)
|
||
|
||
* [Rommel Martinez - A Gentle Introduction to the Nix Family]
|
||
(https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)
|