learnxinyminutes-docs/sv-se/nix-sv.html.markdown
2024-10-20 14:46:35 -07:00

366 lines
9.7 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
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).
```nix
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/)
* [Zero to Nix - Nix Tutorial](https://zero-to-nix.com/)
* [Rommel Martinez - A Gentle Introduction to the Nix Family](https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)