Senden einer SMS in Haskell

Lesezeit: 4 Minuten

July 12, 2017

Autor:in:

Twilion

Senden einer SMS in Haskell

Hallo und Danke fürs Lesen! Dieser Blogpost ist eine Übersetzung von How to Send an SMS in Haskell. Während wir unsere Übersetzungsprozesse verbessern, würden wir uns über Dein Feedback an help@twilio.com freuen, solltest Du etwas bemerken, was falsch übersetzt wurde. Wir bedanken uns für hilfreiche Beiträge mit Twilio Swag :)

Funktionale Programmiersprachen erfreuen sich immer größerer Beliebtheit, und dazu gehört auch Haskell. Sehen wir uns diese Programmiersprache etwas genauer an. Mit Haskell lässt sich Code sauber, präzise und aussagekräftig schreiben. Du bist noch skeptisch?

Vergleich der Java- und Haskell-Programme

Die oben dargestellten Java- und Haskell-Programme erstellen zwei Listen: eine Liste für alle geraden Zahlen bis 100 und eine zweite Liste für dieselben geraden Zahlen, aber ohne die ersten fünf Zahlen. Welche Liste sieht übersichtlicher aus?

Befassen wir uns zuerst mit der Einrichtung der Haskell-Entwicklerumgebung. Dazu müssen wir folgende Aufgaben ausführen:

Zwei Paket-Manager konfigurieren
Haskell installieren
Ein „Hello, World“-Programm erstellen
Unsere erste SMS mit Twilio über Haskell senden (hier erhalten wir eine Twilio-Telefonnummer)

IDEs für Haskell

Für Haskell gibt es noch keine vollständige IDE (wenn du also eine erstellen möchtest, dann steht dir der Markt offen). Viele Haskellers nutzen Atom, da es über die Pakete language-haskell und ide-haskell verfügt, deren Syntaxhervorhebung von Aspekten wie import-Anweisungen sie von anderen Paketen unterscheidet. Sie unterstützen auch das automatische Einrücken und die automatische Vervollständigung sowie die Identifizierung von Typen. Mein Haskell-Professor empfiehlt Atom mit Emacs, das im Terminal funktioniert und eine gute Syntaxhervorhebung und Codevervollständigung hat. An alle Vim-Fans dort draußen: Keine Angst! Vim und Haskell können folgendermaßen eingerichtet werden. Wir können auch Eclipse mit diesem Plug-in zur Farbhervorhebung ausprobieren. Oder aber Leksah, das in Haskell geschrieben ist, Cabal-Paketformat verwendet und mehrere Fenster unterstützt. Ich bevorzuge jedoch Sublime Text 3, vor allem weil ich es von der Webentwicklung her gewohnt bin. Es stellt ein SublimeHaskell-Paket mit intelligenter Vervollständigung, Typrückschluss und Hervorhebung von Fehlern und Warnungen bereit und bildet die Grundlage dieses Blogbeitrags.

Installieren von Haskell

Der interaktive Glasgow Haskell Compiler (GHC) ist Open Source und findet sich auf GitHub. Wir installieren Haskell und GHC auf einem Mac von hier oder auf einem PC von hier. Um die Installation zu testen, führen wir $ghci in der Befehlszeile aus. Wenn alles richtig installiert ist, sollten wir in etwa Folgendes sehen.

Erfolgreiche Haskell-Installation in der Befehlszeile

Finden und Herunterladen von Haskell-Paketen

Ein Paket ist eine Bibliothek mit Haskell-Modulen, die der Compiler erkennt. Diese Module enthalten Funktionen und Typen, mit denen wir Probleme beim Programmieren lösen können und die uns die Arbeit mit REST-APIs (wie Twilio!) ermöglichen. Wo aber finden wir diese Haskell-Pakete, mit denen wir programmieren können? Stackage und Hackage stellen Open-Source-Pakete bereit, die wir mit den Stack- und Cabal-Paket-Managern herunterladen. Der Hauptunterschied zwischen den beiden besteht darin, dass Stackage nur eine Teilmenge der Pakete bietet, die Hackage bereitstellt. Hackage-Pakete könnten Abhängigkeitsprobleme verursachen, aber die meisten sind sofort einsatzbereit. Insgesamt hat Hackage eine größere Verbreitung und Vielfalt zur Auswahl.

Verwalten von Haskell-Paketen mit Stack

Stack ist mein bevorzugter Paket-Manager für Haskell. Stack ist isoliert, d. h. es werden keine Änderungen außerhalb von bestimmten Stack-Verzeichnissen vorgenommen, wenn wir in der Befehlszeile stack install ausführen. Beim Erstellen mit Stack werden reproduzierbare Builds erstellt (auch bekannt als Paketzwischenspeicherung). Das bedeutet, dass stack build morgen dasselbe ausführt wie heute, solange nichts am Code geändert wird. Stack bietet außerdem eine ansprechende, saubere Entwicklererfahrung.

Auf einem Mac geben wir zur Installation Folgendes in die Befehlszeile ein:

curl -sSL https://get.haskellstack.org/ | sh

Bei Verwendung von Windows installieren wir Stack mit diesem Windows 64-Bit-Installationsprogramm. Weitere Informationen zu Stack finden wir auf der Seite „Install/upgrade“.

Mit Stack ist es ein Leichtes, unser erstes Projekt einzurichten. Der nächste Abschnitt wird im Terminal ausgeführt und zeigt, wie wir ein neues Stack-Projekt anlegen. Wir ersetzen alle Zeichenfolgen, die mit „your“ beginnen durch einen Namen unserer Wahl.

stack new your-hask-project #new directory w/ starter files
cd your-hask-project #get into direc.
stack setup #download compiler
stack build #build project
stack install your-hask-package #install an executable package ie Twilio
stack exec your-hask-project #execute project command (start server, run proj, etc)

Verwalten von Haskell-Paketen mit Cabal

Der andere weit verbreitete Haskell-Paket-Manager ist Cabal. Dieser ist auf der Haskell-Plattform enthalten, was darauf schließen ließe, dass er einfacher zu verwenden wäre ... aber weit gefehlt! Wirklich? Viele Haskellers, die ich bisher getroffen habe, sind keine großen Fans von Cabal. Mein größtes Problem mit Haskell sind die Schwierigkeiten mit den Cabal-Abhängigkeiten (auch bekannt als Cabal-Hölle). Wie können wir dieses Problem lösen? Mit Sandboxen. Diese ermöglichen Entwicklern, Pakete zu isolieren und zu erstellen, indem für jedes Paket eine private Paketumgebung erzeugt wird, wie bei der Virtualenv von Python.

Um Cabal zu installieren, führen wir im Terminal folgenden Befehl aus:

cabal init  #creates Setup.hs, .cabal file for you, asks questions
cabal sandbox init
cabal install hask-package-you-want
cabal build

Hello World in Haskell

Um Hello World zu erhalten, sind keine Pakete erforderlich. In der Befehlszeile geben wir ghci ein und nach dem Drücken der Eingabetaste geben wir Folgendes ein:

putStrLn "Hello, World"

Das ging unheimlich schnell, nicht wahr?

Wie wäre es, wenn wir „Hello, World“ aus einer Haskell-Datei erstellen? Hierzu erstellen wir ein neues Verzeichnis, in dem unser Projekt enthalten sein soll, und nennen es sms. In diesem Verzeichnis erstellen wir eine Datei mit dem Namen first.hs und in der ersten Zeile schreiben wir:

main = putStrLn "Hello World"

Zurück in der Befehlszeile schreiben wir Folgendes, um die Datei zu kompilieren.

ghc -o hello first.hs

Dann führen wir die Programmdatei hello aus. Dazu geben wir Folgendes in die Befehlszeile ein:

./hello

Voila! Wir haben auf zwei verschiedene Arten Hello, World in Haskell erstellt.

Senden einer SMS mit Haskell

Zuerst benötigen wir eine Twilio-Telefonnummer, die Textnachrichten empfangen kann. Wenn wir noch keine Nummer haben, können wir uns hier eine besorgen.

Wir benötigen unsere Twilio-Konto-SID und das Authentifizierungstoken zum Senden von Textnachrichten. Diese finden wir in der Konsole. Wir speichern sie als Umgebungsvariablen. Wenn wir in einem Windows-basierten System arbeiten, bietet uns dieser Blogbeitrag eine Anleitung dazu. In einem Unix-basierten System richten wir die Umgebungsvariablen ein, indem wir die folgenden zwei Zeilen in die Shell eingeben und diese dem .bash_profile hinzufügen.

export TWILIO_ACCOUNT_SID="YOUR_ACCOUNT_SID"
export TWILIO_AUTH_TOKEN="YOUR_AUTH_TOKEN"

In der Befehlszeile in unserem sms-Verzeichnis führen wir stack new sms aus. Dadurch werden in unserem Projekt die folgenden Dateien eingerichtet: sms.cabal, stack.yaml, Setup.hs und Main.hs. In der Datei sms.cabal suchen wir die Zeile, die mit build-depends der Programmdatei beginnt und entfernen die Zeile, die mit build-depends beginnt, die sich darin befindet. Wir fügen Folgendes an dieser Stelle ein, damit Twilio verwendet wird:

build-depends: base
 , twilio
 , transformers

Als Nächstes geben wir in der Befehlszeile „stack init --solver“ ein, damit Stack ein Paket bestimmen kann, das mit unserer sms.cabal-Datei kompatibel ist. Anschließend öffnen wir in unserer bevorzugten IDE (siehe dazu meine Überlegungen oben) das soeben erstellte Verzeichnis.

Jetzt öffnen wir Main.hs (befindet sich im app-Ordner) und löschen den darin vorhandenen Code. Stattdessen geben wir den folgenden Code ein. Da wir unsere erste SMS senden, müssen wir den folgenden Teil mit der Telefonnummer, an die wir eine SMS senden möchten, und unsere eigene Twilio-Telefonnummer aktualisieren:

{-#LANGUAGE OverloadedStrings #-}
module Main where
import Control.Monad.IO.Class(liftIO)
import System.Environment (getEnv)
import Twilio
import Twilio.Messages
main:: IO()
main = runTwilio' (getEnv "TWILIO_ACCOUNT_SID")
                  (getEnv "TWILIO_AUTH_TOKEN") $ do
  let body = PostMessage "NUMBER_TO_TEXT" "YOUR_TWILIO_NUMBER" "Hello, World!"
  message <- post body
  liftIO $ print message

Der nächste Schritt wird eine Weile dauern. Zum Zeitvertreib empfehle ich einen der folgenden Artikel in den Hacker News. In der Befehlszeile geben wir Folgendes ein:

stack build

Nachdem dieser Schritt abgeschlossen ist, führen wir die Programmdatei aus. Hierzu geben wir Folgendes in die Befehlszeile ein:

stack exec sms-exe

https://media.giphy.com/media/bQCWmEgKHasZG/giphy.gif

Ein voller Erfolg! Wir sollten jetzt eine SMS in Haskell gesendet haben und Folgendes im Terminal sehen:

Erfolgreiches Senden von SMS im Terminal

Wenn wir eine Fehlermeldung wie „getEnv: does not exist (no environment variable)“ erhalten, müssen wir überprüfen, ob die Umgebungsvariablen korrekt eingestellt sind und ob die entsprechenden Variablennamen stimmen. Dann öffnen wir ein Terminalfenster und führen folgenden Befehl aus:

source ~/.bash_profile

Weitere Informationen zu Haskell

Möchtest du mehr über Haskell im Allgemeinen erfahren? Dann empfehle ich das Tutorial Learn You a Haskell und das Buch Real World Haskell von O‘Reilly. Weitere Beiträge zu Haskell sind geplant, um dir mehr Informationen zu dieser funktionalen Programmiersprache zu vermitteln. Mich würde außerdem deine Meinung zu den verschiedenen IDEs, zu Cabal oder Stack oder Haskell im Allgemeinen interessieren.

E-Mail: lsiegle@twilio.com

GitHub: elizabethsiegle

Twitter: @lizziepika