TL; DR
{-# LANGUAGE InstanceSigs #-}
newtype Id t = Id t
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
อารัมภบท
ผู้ประกอบการแอปพลิเคชัน$ของฟังก์ชั่น
forall a b. a -> b
ถูกกำหนดตามมาตรฐาน
($) :: (a -> b) -> a -> b
f $ x = f x
infixr 0 $
ในแง่ของการประยุกต์ใช้ฟังก์ชั่นดั้งเดิม Haskell f x( infixl 10)
องค์ประกอบ.ถูกกำหนดในแง่ของ$เป็น
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x
infixr 9 .
และตอบสนองความเท่าเทียมกัน forall f g h.
f . id = f :: c -> d Right identity
id . g = g :: b -> c Left identity
(f . g) . h = f . (g . h) :: a -> d Associativity
.มีการเชื่อมโยงและidเป็นตัวตนทางขวาและซ้าย
Kleisli สามคน
ในการเขียนโปรแกรม monad เป็นตัวสร้างประเภท functor ที่มีอินสแตนซ์ของคลาสประเภท monad มีคำจำกัดความและการใช้งานที่เทียบเท่าหลายรูปแบบแต่ละแบบมีสัญชาติญาณที่แตกต่างกันเล็กน้อยเกี่ยวกับสิ่งที่เป็นนามธรรม
functor เป็นตัวสร้างfประเภทที่* -> *มีประเภทของคลาสประเภท functor
{-# LANGUAGE KindSignatures #-}
class Functor (f :: * -> *) where
map :: (a -> b) -> (f a -> f b)
นอกเหนือจากโปรโตคอลประเภทบังคับใช้แบบคงที่แล้วอินสแตนซ์ของคลาสประเภท functor ต้องเป็นไปตามกฎหมายเกี่ยวกับพีชคณิตfunctor forall f g.
map id = id :: f t -> f t Identity
map f . map g = map (f . g) :: f a -> f c Composition / short cut fusion
การคำนวณ Functor มีประเภท
forall f t. Functor f => f t
คำนวณc rประกอบด้วยในผล rภายในบริบท c
ฟังก์ชั่นเอกนารีหรือลูกศร Kleisliมีประเภท
forall m a b. Functor m => a -> m b
ลูกศร Kleisi มีฟังก์ชั่นที่ใช้อาร์กิวเมนต์หนึ่งและกลับคำนวณเอกam b
Monads ถูกกำหนดตามแบบบัญญัติในแง่ของKleisli triple forall m. Functor m =>
(m, return, (=<<))
ดำเนินการเป็นคลาสประเภท
class Functor m => Monad m where
return :: t -> m t
(=<<) :: (a -> m b) -> m a -> m b
infixr 1 =<<
ตัวตน Kleisli returnเป็นลูกศร Kleisli ที่ส่งเสริมค่าในบริบทเอกt ขยายหรือKleisli แอพลิเคชันได้ใช้ Kleisli ลูกศรผลของการคำนวณm =<<a -> m bm a
องค์ประกอบของ Kleisli <=<ถูกกำหนดในแง่ของการขยายเป็น
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=< ประกอบด้วยลูกศร Kleisli สองลูกโดยใช้ลูกศรซ้ายกับผลลัพธ์ของแอปพลิเคชันลูกศรขวา
อินสแตนซ์ของคลาสประเภท monad ต้องเป็นไปตามกฎของ monadที่ระบุไว้อย่างหรูหราที่สุดในแง่ขององค์ประกอบ Kleisli:forall f g h.
f <=< return = f :: c -> m d Right identity
return <=< g = g :: b -> m c Left identity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d Associativity
<=<มีการเชื่อมโยงและreturnเป็นตัวตนทางขวาและซ้าย
เอกลักษณ์
ประเภทข้อมูลประจำตัว
type Id t = t
เป็นฟังก์ชั่นเอกลักษณ์ในประเภท
Id :: * -> *
ตีความว่าเป็นนักแสดง
return :: t -> Id t
= id :: t -> t
(=<<) :: (a -> Id b) -> Id a -> Id b
= ($) :: (a -> b) -> a -> b
(<=<) :: (b -> Id c) -> (a -> Id b) -> (a -> Id c)
= (.) :: (b -> c) -> (a -> b) -> (a -> c)
ใน canonical Haskell จะมีการกำหนด monad เอกลักษณ์
newtype Id t = Id t
instance Functor Id where
map :: (a -> b) -> Id a -> Id b
map f (Id x) = Id (f x)
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
ตัวเลือก
ประเภทตัวเลือก
data Maybe t = Nothing | Just t
เข้ารหัสการคำนวณMaybe tที่ไม่จำเป็นต้องให้ผลลัพธ์ผลลัพธ์tการคำนวณที่อาจ“ ล้มเหลว” ตัวเลือก monad ถูกกำหนดไว้
instance Functor Maybe where
map :: (a -> b) -> (Maybe a -> Maybe b)
map f (Just x) = Just (f x)
map _ Nothing = Nothing
instance Monad Maybe where
return :: t -> Maybe t
return = Just
(=<<) :: (a -> Maybe b) -> Maybe a -> Maybe b
f =<< (Just x) = f x
_ =<< Nothing = Nothing
a -> Maybe bถูกนำไปใช้กับผลลัพธ์ก็ต่อเมื่อได้Maybe aผลลัพธ์
newtype Nat = Nat Int
ตัวเลขธรรมชาติสามารถเข้ารหัสเป็นจำนวนเต็มมากกว่าหรือเท่ากับศูนย์
toNat :: Int -> Maybe Nat
toNat i | i >= 0 = Just (Nat i)
| otherwise = Nothing
ตัวเลขธรรมชาติไม่ได้ถูกปิดภายใต้การลบ
(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)
infixl 6 -?
Monad ตัวเลือกครอบคลุมรูปแบบพื้นฐานของการจัดการข้อยกเว้น
(-? 20) <=< toNat :: Int -> Maybe Nat
รายการ
รายการ monad เหนือประเภทรายการ
data [] t = [] | t : [t]
infixr 5 :
และการดำเนินการ monoid เสริมของมัน "ผนวก"
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
ถอดรหัสไม่เชิงเส้นคำนวณ[t]ผลผลิตเป็นจำนวนธรรมชาติของผลลัพธ์0, 1, ...t
instance Functor [] where
map :: (a -> b) -> ([a] -> [b])
map f (x : xs) = f x : map f xs
map _ [] = []
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> [a] -> [b]
f =<< (x : xs) = f x ++ (f =<< xs)
_ =<< [] = []
ส่วนต่อขยาย=<<เชื่อม++แสดงรายการทั้งหมด[b]ที่เกิดจากการใช้งานf xของ Kleisli ลูกศรa -> [b]เพื่อองค์ประกอบของการเป็นรายการผลเดียว[a][b]
ปล่อยให้ตัวหารที่เหมาะสมของจำนวนเต็มบวกnเป็น
divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]
divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)
แล้วก็
forall n. let { f = f <=< divisors } in f n = []
ในการกำหนดระดับประเภท monad แทนการขยาย=<<การใช้มาตรฐาน Haskell พลิกระบุผูก>>=ประกอบการ
class Applicative m => Monad m where
(>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
m >> k = m >>= \ _ -> k
{-# INLINE (>>) #-}
return :: a -> m a
return = pure
เพื่อความเรียบง่ายคำอธิบายนี้ใช้ลำดับชั้นของคลาสชนิด
class Functor f
class Functor m => Monad m
ใน Haskell ลำดับชั้นมาตรฐานปัจจุบันคือ
class Functor f
class Functor p => Applicative p
class Applicative m => Monad m
เพราะไม่เพียง แต่จะเป็นนักแสดงทุกคนเท่านั้น แต่ผู้สมัครทุกคนเป็นนักแสดง
การใช้ list monad คือ pseudocode ที่จำเป็น
for a in (1, ..., 10)
for b in (1, ..., 10)
p <- a * b
if even(p)
yield p
ๆ แปลไปยังบล็อกที่ต้องทำ ,
do a <- [1 .. 10]
b <- [1 .. 10]
let p = a * b
guard (even p)
return p
เทียบเท่าเข้าใจ monad ,
[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]
และการแสดงออก
[1 .. 10] >>= (\ a ->
[1 .. 10] >>= (\ b ->
let p = a * b in
guard (even p) >> -- [ () | even p ] >>
return p
)
)
สัญกรณ์และความเข้าใจ monad เป็นน้ำตาลประโยคสำหรับการแสดงออกที่ซ้อนกันผูก ตัวดำเนินการเชื่อมโยงใช้สำหรับการโยงชื่อโลคัลของผลลัพธ์ monadic
let x = v in e = (\ x -> e) $ v = v & (\ x -> e)
do { r <- m; c } = (\ r -> c) =<< m = m >>= (\ r -> c)
ที่ไหน
(&) :: a -> (a -> b) -> b
(&) = flip ($)
infixl 0 &
กำหนดฟังก์ชั่นป้องกัน
guard :: Additive m => Bool -> m ()
guard True = return ()
guard False = fail
พื้นที่ที่หน่วยประเภทหรือ“ tuple ว่างเปล่า”
data () = ()
พระเสริมที่สนับสนุนทางเลือกและความล้มเหลวสามารถถูกแยกออกโดยใช้คลาสประเภท
class Monad m => Additive m where
fail :: m t
(<|>) :: m t -> m t -> m t
infixl 3 <|>
instance Additive Maybe where
fail = Nothing
Nothing <|> m = m
m <|> _ = m
instance Additive [] where
fail = []
(<|>) = (++)
ที่ไหนfailและ<|>รูปแบบ monoidforall k l m.
k <|> fail = k
fail <|> l = l
(k <|> l) <|> m = k <|> (l <|> m)
และfailเป็นองค์ประกอบที่ดูดซับ / ทำลายศูนย์ของพระสงฆ์เสริม
_ =<< fail = fail
หากเข้า
guard (even p) >> return p
even pเป็นจริงจากนั้นตัวสร้างจะสร้าง[()]และตามนิยามของ>>ฟังก์ชันค่าคงที่โลคัล
\ _ -> return p
()ถูกนำไปใช้ผล หากเป็นเท็จระบบจะสร้างรายการของ monad fail( []) ซึ่งไม่ได้ผลสำหรับลูกศร Kleisli ที่จะนำไปใช้>>ดังนั้นสิ่งนี้pจะถูกข้ามไป
สถานะ
น่าอับอายพระใช้เพื่อเข้ารหัสการคำนวณ stateful
โปรเซสเซอร์รัฐเป็นฟังก์ชั่น
forall st t. st -> (t, st)
ที่เปลี่ยนรัฐและอัตราผลตอบแทนผลst รัฐสามารถเป็นอะไรก็ได้ ไม่มีอะไร, ธง, นับ, อาเรย์, จัดการ, เครื่องจักร, โลกt st
ชนิดของตัวประมวลผลสถานะมักเรียกว่า
type State st t = st -> (t, st)
รัฐโปรเซสเซอร์ monad เป็น* -> *functor State stชนิด ลูกศร Kleisli ของตัวประมวลผลสถานะ monad เป็นฟังก์ชัน
forall st a b. a -> (State st) b
ใน canonical Haskell จะมีการกำหนดเวอร์ชันสันหลังยาวของตัวประมวลผลสถานะ monad
newtype State st t = State { stateProc :: st -> (t, st) }
instance Functor (State st) where
map :: (a -> b) -> ((State st) a -> (State st) b)
map f (State p) = State $ \ s0 -> let (x, s1) = p s0
in (f x, s1)
instance Monad (State st) where
return :: t -> (State st) t
return x = State $ \ s -> (x, s)
(=<<) :: (a -> (State st) b) -> (State st) a -> (State st) b
f =<< (State p) = State $ \ s0 -> let (x, s1) = p s0
in stateProc (f x) s1
ตัวประมวลผลสถานะทำงานโดยการระบุสถานะเริ่มต้น:
run :: State st t -> st -> (t, st)
run = stateProc
eval :: State st t -> st -> t
eval = fst . run
exec :: State st t -> st -> st
exec = snd . run
การเข้าถึงของรัฐที่ให้บริการโดยพื้นฐานgetและputวิธีการที่เป็นนามธรรมมากกว่าstateful monads:
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m -> stประกาศการพึ่งพาการทำงานของประเภทรัฐstใน Monad m; ที่State tยกตัวอย่างเช่นจะเป็นตัวกำหนดประเภทของรัฐที่จะต้องtไม่ซ้ำกัน
instance Stateful (State st) st where
get :: State st st
get = State $ \ s -> (s, s)
put :: st -> State st ()
put s = State $ \ _ -> ((), s)
ด้วยประเภทหน่วยที่ใช้แบบอะนาล็อกกับเป็นvoidC
modify :: Stateful m st => (st -> st) -> m ()
modify f = do
s <- get
put (f s)
gets :: Stateful m st => (st -> t) -> m t
gets f = do
s <- get
return (f s)
gets มักใช้กับอุปกรณ์บันทึกข้อมูล
สถานะ monad ที่เทียบเท่าของเธรดตัวแปร
let s0 = 34
s1 = (+ 1) s0
n = (* 12) s1
s2 = (+ 7) s1
in (show n, s2)
ที่s0 :: Intมีความโปร่งใสเท่า ๆ กัน แต่มีความสง่างามและใช้งานได้จริง
(flip run) 34
(do
modify (+ 1)
n <- gets (* 12)
modify (+ 7)
return (show n)
)
modify (+ 1)คือการคำนวณจากประเภทState Int ()ยกเว้นของผลreturn ()เทียบเท่ากับ
(flip run) 34
(modify (+ 1) >>
gets (* 12) >>= (\ n ->
modify (+ 7) >>
return (show n)
)
)
กฎของการเชื่อมโยง monad สามารถเขียนได้ในรูปของ >>= forall m f g.
(m >>= f) >>= g = m >>= (\ x -> f x >>= g)
หรือ
do { do { do {
r1 <- do { x <- m; r0 <- m;
r0 <- m; = do { = r1 <- f r0;
f r0 r1 <- f x; g r1
}; g r1 }
g r1 }
} }
เช่นเดียวกับในการเขียนโปรแกรมเชิงแสดงออก (เช่นสนิม) คำสั่งสุดท้ายของบล็อกแสดงถึงผลผลิตของมัน ตัวดำเนินการเชื่อมโยงบางครั้งเรียกว่า "อัฒภาคแบบตั้งโปรแกรมได้"
โครงสร้างการควบคุมการทำซ้ำแบบดั้งเดิมจากการเขียนโปรแกรมความจำเป็นเชิงโครงสร้างจะถูกจำลองแบบ monadically
for :: Monad m => (a -> m b) -> [a] -> m ()
for f = foldr ((>>) . f) (return ())
while :: Monad m => m Bool -> m t -> m ()
while c m = do
b <- c
if b then m >> while c m
else return ()
forever :: Monad m => m t
forever m = m >> forever m
Input / Output
data World
Monad state processor I / O โลกคือการประนีประนอม Haskell บริสุทธิ์และโลกแห่งความเป็นจริงของความหมายเชิงปฏิบัติการ denotative และความจำเป็นในการดำเนินงาน อะนาล็อกที่ใกล้เคียงกับการใช้งานจริงอย่างเข้มงวด:
type IO t = World -> (t, World)
การโต้ตอบจะช่วยอำนวยความสะดวกโดยไม่บริสุทธิ์ดั้งเดิม
getChar :: IO Char
putChar :: Char -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hTell :: Handle -> IO Integer
. . . . . .
ความไม่บริสุทธิ์ของรหัสที่ใช้IOprimitives ถูกโพรโทคอลอย่างถาวรโดยระบบชนิด เพราะความบริสุทธิ์นั้นยอดเยี่ยมสิ่งที่เกิดขึ้นIOอยู่ในIOนั้น
unsafePerformIO :: IO t -> t
หรืออย่างน้อยควร
ลายเซ็นประเภทของโปรแกรม Haskell
main :: IO ()
main = putStrLn "Hello, World!"
ขยายเป็น
World -> ((), World)
ฟังก์ชั่นที่เปลี่ยนโลก
ถ้อยคำส
วัตถุประเภทการ whiches มี Haskell ชนิดและ whiches morphisms มีฟังก์ชั่นระหว่างประเภท Haskell คือ“ได้อย่างรวดเร็วและหลวม” Haskหมวดหมู่
functor Tคือการทำแผนที่จากหมวดหมู่Cไปที่ประเภทD; สำหรับแต่ละวัตถุในCวัตถุในD
Tobj : Obj(C) -> Obj(D)
f :: * -> *
และสำหรับแต่ละมอร์ฟิซึ่มส์ในCมอร์ฟิซึ่มในD
Tmor : HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
map :: (a -> b) -> (f a -> f b)
ที่X, มีวัตถุในY เป็นระดับ homomorphismของ morphisms ทั้งหมดใน functor ต้องรักษาตัวตนซึ่มส์และองค์ประกอบที่“โครงสร้าง” ของในCHomC(X, Y)X -> YCCD
Tmor Tobj
T(id) = id : T(X) -> T(X) Identity
T(f) . T(g) = T(f . g) : T(X) -> T(Z) Composition
หมวด Kleisliของหมวดหมู่นี้Cจะได้รับโดย Kleisli สาม
<T, eta, _*>
ของ endofunctor
T : C -> C
( f), มอร์ฟิซึ่มเอกลักษณ์eta( return) และผู้ดำเนินการส่วนขยาย*( =<<)
แต่ละมอร์ฟิซึ่ม Kleisli ใน Hask
f : X -> T(Y)
f :: a -> m b
โดยผู้ประกอบการส่วนขยาย
(_)* : Hom(X, T(Y)) -> Hom(T(X), T(Y))
(=<<) :: (a -> m b) -> (m a -> m b)
ได้รับ morphism ในHaskหมวดหมู่ของ Kleisli
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
องค์ประกอบในหมวดหมู่ Kleisli .Tนั้นได้รับในแง่ของการขยาย
f .T g = f* . g : X -> T(Z)
f <=< g = (f =<<) . g :: a -> m c
และสอดคล้องกับสัจพจน์หมวดหมู่
eta .T g = g : Y -> T(Z) Left identity
return <=< g = g :: b -> m c
f .T eta = f : Z -> T(U) Right identity
f <=< return = f :: c -> m d
(f .T g) .T h = f .T (g .T h) : X -> T(U) Associativity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d
ซึ่งใช้การแปลงสมมูล
eta .T g = g
eta* . g = g By definition of .T
eta* . g = id . g forall f. id . f = f
eta* = id forall f g h. f . h = g . h ==> f = g
(f .T g) .T h = f .T (g .T h)
(f* . g)* . h = f* . (g* . h) By definition of .T
(f* . g)* . h = f* . g* . h . is associative
(f* . g)* = f* . g* forall f g h. f . h = g . h ==> f = g
ในแง่ของการขยายจะได้รับบัญญัติ
eta* = id : T(X) -> T(X) Left identity
(return =<<) = id :: m t -> m t
f* . eta = f : Z -> T(U) Right identity
(f =<<) . return = f :: c -> m d
(f* . g)* = f* . g* : T(X) -> T(Z) Associativity
(((f =<<) . g) =<<) = (f =<<) . (g =<<) :: m a -> m c
Monads ยังสามารถกำหนดได้ในแง่ของการขยายไม่ Kleislian แต่การเปลี่ยนแปลงทางธรรมชาติmu, joinการเขียนโปรแกรมที่เรียกว่าใน Monad ถูกกำหนดในแง่ของการmuเป็นสามเท่าของหมวดหมู่Cของ endofunctor
T : C -> C
f :: * -> *
และสองรูปแบบตามธรรมชาติ
eta : Id -> T
return :: t -> f t
mu : T . T -> T
join :: f (f t) -> f t
ความพึงพอใจเทียบเท่า
mu . T(mu) = mu . mu : T . T . T -> T . T Associativity
join . map join = join . join :: f (f (f t)) -> f t
mu . T(eta) = mu . eta = id : T -> T Identity
join . map return = join . return = id :: f t -> f t
คลาสประเภท monad ถูกกำหนดแล้ว
class Functor m => Monad m where
return :: t -> m t
join :: m (m t) -> m t
การmuใช้งานตามบัญญัติของ monad ตัวเลือก:
instance Monad Maybe where
return = Just
join (Just m) = m
join Nothing = Nothing
concatฟังก์ชั่น
concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat [] = []
เป็นjoinของรายการ monad
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> ([a] -> [b])
(f =<<) = concat . map f
การใช้งานของjoinสามารถแปลได้จากรูปแบบการขยายโดยใช้เทียบเท่า
mu = id* : T . T -> T
join = (id =<<) :: m (m t) -> m t
การแปลแบบย้อนกลับจากmuเป็นรูปแบบส่วนขยายได้รับจาก
f* = mu . T(f) : T(X) -> T(Y)
(f =<<) = join . map f :: m a -> m b
แต่ทำไมทฤษฎีควรให้นามธรรมใช้สำหรับการเขียนโปรแกรมใด ๆ
คำตอบนั้นง่าย: ในฐานะนักวิทยาศาสตร์คอมพิวเตอร์เราเห็นคุณค่าของความเป็นนามธรรม ! เมื่อเราออกแบบส่วนต่อประสานกับส่วนประกอบซอฟต์แวร์เราต้องการให้มันเปิดเผยน้อยที่สุดเกี่ยวกับการใช้งาน เราต้องการที่จะสามารถแทนที่การใช้งานด้วยทางเลือกมากมาย 'อินสแตนซ์' อื่น ๆ ของ 'แนวคิด' เดียวกัน เมื่อเราออกแบบอินเทอร์เฟซทั่วไปให้กับไลบรารีโปรแกรมจำนวนมากสิ่งสำคัญยิ่งกว่าคืออินเตอร์เฟสที่เราเลือกนั้นมีการใช้งานที่หลากหลาย มันเป็นความคิดทั่วไปของแนวคิด monad ที่เราให้คุณค่าอย่างมากมันเป็นเพราะทฤษฎีหมวดหมู่นั้นเป็นนามธรรมดังนั้นแนวคิดของมันจึงมีประโยชน์สำหรับการเขียนโปรแกรม
มันแทบจะไม่น่าแปลกใจเลยที่การวางหลักเกณฑ์ทั่วไปของพระที่เรานำเสนอไว้ด้านล่างนี้ยังมีความสัมพันธ์ใกล้ชิดกับทฤษฎีหมวดหมู่ แต่เราเน้นว่าจุดประสงค์ของเรานั้นใช้ได้จริงมากไม่ใช่เพื่อ 'ใช้ทฤษฎีหมวดหมู่' แต่เป็นการหาวิธีทั่วไปในการจัดโครงสร้างไลบรารี combinator เป็นเพียงความโชคดีของเราที่นักคณิตศาสตร์ได้ทำงานมามากมายสำหรับเรา!
จากGeneralising Monads ถึง Arrowsโดย John Hughes
