haskell求解一元二次方程

灰暗已经过去，又开始写文章啦啦啦！！！

1， 之前学习大数据要用到scala语言，遇到scala里面的函数式部分有点懵逼。后来就想深入学习一下函数式语言。现在的很多命令式语言都支持函数式风格，但是因为命令式的思想根深蒂固多年很多函数式的思想很难理解。于是就想直接从一门纯粹的函数式语言入手从零开始学习函数式编程思想。去年在工作空闲时花过一段时间学习haskell，当时有点晕，很多东西没搞明白，后来事情太多中断了。如今有空了，再继续吧。

本文先从Haskell Cookbook上的求解一元二次方程开始吧，熟悉一下语法。

2， 配置环境：按照haskell文档安装stack，别用brew install stack，版本太旧，问题多多。
haskell官方IDE是基于eclipse的，不太好用，目前直接使用vs code。

3， stack new hello新建工程。

项目结构.png

-- Quadratic.hs
module Quadratic where

-- 导入模块
import Data.Complex

-- 定义数据类型：record格式
-- =号左边叫类型构造，可以接受类型参数，相当于定义泛形类型
-- =号右边叫数据构造，有两个参数时数据构造名称可以放中间，数据构造按是否指定字段名分两种格式
-- record格式每个字段名自身是一个函数 类型为 数据构造 -> 字段类型，所以访问对象字段的格式：(字段名 对象名)
data Quadratic = Quadratic {a :: Double, b :: Double, c :: Double}
                              deriving Show

-- 定义类型别名 相当于c++中的 typedef/using
type RootT = Complex Double

-- 定义数据类型：只指明字段类型，没有字段名称
data Roots = Roots RootT RootT 
                      deriving Show

-- 定义函数头
roots :: Quadratic -> Roots

-- 定义函数体
-- 模式匹配 _表示忽略具体值  error抛异常
roots (Quadratic 0 0 _) = error "不是一元二次方程"

-- let <bindings> in expression
roots (Quadratic 0.0 b c) = let root = ((-c) / b :+ 0)
                        in Roots root root

roots (Quadratic a b c) = let discriminant = b * b - 4 * a * c
                    in rootsInternal (Quadratic a b c) discriminant

rootsInternal :: Quadratic -> Double -> Roots
-- |之后表示模式匹配的条件，满足条件才能匹配上然后执行对应的逻辑
-- 同一个语句块必须左对齐
rootsInternal q d  | d == 0 = let r = (-(b q) / 2.0 / (a q)) 
                                  root = r :+ 0
                              in Roots root root

-- expression where <bindings>
rootsInternal q d | d < 0 = Roots (realpart :+ complexpart) (realpart :+ (-complexpart)) 
                where plusd = -d
                      twoa = 2.0 * (a q)
                      complexpart = (sqrt plusd) / twoa
                      realpart = - (b q) / twoa

rootsInternal q d | d < 0 = Roots (root1 :+ 0) (root2 :+ 0) 
                where plusd = -d
                      twoa = 2.0 * (a q)
                      dpart = (sqrt plusd) / twoa
                      prefix = -(b q) / twoa
                      root1 = prefix + dpart
                      root2 = prefix - dpart
   
-- Main.hs                 
module Main where

import Quadratic
import Data.Complex

str2double :: String -> Double
str2double str = read str :: Double 

main :: IO ()
main = do
    print "input a"
    a <- getLine
    print "input b"
    b <- getLine
    print "input c"
    c <- getLine

    -- $ 函数调用顺序从右往左
    putStrLn $ show $ roots (Quadratic (str2double a) (str2double b) (str2double c))

4， 编译执行
stack build
stack exec -- hello-exe

exec.png

5， 语法非常的神奇，去年一直搞不懂，现在再看有点明白了(可能是内力更深了，哈哈哈)。

6， haskell采用缩进语法，但是没有python那么严格，只要求同一个语句块左边对齐(？？？)。