[{"name":"Units.Acceleration","comment":" An `Acceleration` represents an acceleration in meters per second squared,\nfeet per second squared or [gees][1]. It is stored as a number of meters per\nsecond squared.\n\nNote that since `MetersPerSecondSquared` is defined as `Rate MetersPerSecond\nSeconds` (change in speed per unit time), you can construct an `Acceleration`\nvalue using `Quantity.per`:\n\n    acceleration =\n        changeInSpeed |> Quantity.per duration\n\nYou can also do rate-related calculations with `Acceleration` values to compute\n`Speed` or `Duration`:\n\n    changeInSpeed =\n        acceleration |> Quantity.times duration\n\n    alsoChangeInSpeed =\n        duration |> Quantity.at acceleration\n\n    duration =\n        changeInSpeed |> Quantity.at_ acceleration\n\n[1]: https://en.wikipedia.org/wiki/G-force#Unit_and_measurement\n\n@docs Acceleration, MetersPerSecondSquared\n\n@docs metersPerSecondSquared, inMetersPerSecondSquared, feetPerSecondSquared, inFeetPerSecondSquared, gees, inGees\n\n","unions":[],"aliases":[{"name":"Acceleration","comment":" ","args":[],"type":"Acceleration.Acceleration"},{"name":"MetersPerSecondSquared","comment":" ","args":[],"type":"Acceleration.MetersPerSecondSquared"}],"values":[{"name":"feetPerSecondSquared","comment":" Construct an acceleration from a number of feet per second squared.\n","type":"Basics.Float -> Acceleration.Acceleration"},{"name":"gees","comment":" Construct an acceleration from a number of [gees][1]. One gee is equal to\n9.80665 meters per second squared (the standard acceleration due to gravity).\n\n    Acceleration.gees 1\n    --> Acceleration.metersPerSecondSquared 9.80665\n\n[1]: https://en.wikipedia.org/wiki/G-force#Unit_and_measurement\n\n","type":"Basics.Float -> Acceleration.Acceleration"},{"name":"inFeetPerSecondSquared","comment":" Convert an acceleration to a number of feet per second squared.\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"inGees","comment":" Convert an acceleration to a number of gees.\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"inMetersPerSecondSquared","comment":" Convert an acceleration to a number of meters per second squared.\n","type":"Acceleration.Acceleration -> Basics.Float"},{"name":"metersPerSecondSquared","comment":" Construct an acceleration from a number of meters per second squared.\n","type":"Basics.Float -> Acceleration.Acceleration"}],"binops":[]},{"name":"Units.Angle","comment":" An `Angle` represents an angle in degrees, radians, or turns. It is stored\nas a number of radians.\n\n@docs Angle, Radians\n\n\n## Conversions\n\n@docs radians, inRadians, degrees, inDegrees, turns, inTurns\n\n\n## Trigonometry\n\nIf you're using `Angle` values instead of plain `Float`s, you'll need to use\nthese functions instead of [the corresponding ones in core][1].\n\n[1]: https://package.elm-lang.org/packages/elm/core/latest/Basics#trigonometry\n\n@docs sin, cos, tan, asin, acos, atan, atan2\n\n","unions":[],"aliases":[{"name":"Angle","comment":" ","args":[],"type":"Angle.Angle"},{"name":"Radians","comment":" ","args":[],"type":"Angle.Radians"}],"values":[{"name":"acos","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"asin","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"atan","comment":" ","type":"Basics.Float -> Angle.Angle"},{"name":"atan2","comment":" ","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Angle.Angle"},{"name":"cos","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"degrees","comment":" Construct an angle from a number of degrees.\n\n    Angle.degrees 180\n    --> Angle.radians pi\n\n","type":"Basics.Float -> Angle.Angle"},{"name":"inDegrees","comment":" Convert an angle to a number of degrees.\n\n    Angle.turns 2 |> Angle.inDegrees\n    --> 720\n\n","type":"Angle.Angle -> Basics.Float"},{"name":"inRadians","comment":" Convert an angle to a number of radians.\n","type":"Angle.Angle -> Basics.Float"},{"name":"inTurns","comment":" Convert an angle to a number of turns.\n\n    Angle.radians pi |> Angle.inTurns\n    --> 0.5\n\n","type":"Angle.Angle -> Basics.Float"},{"name":"radians","comment":" Construct an angle from a number of radians.\n","type":"Basics.Float -> Angle.Angle"},{"name":"sin","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"tan","comment":" ","type":"Angle.Angle -> Basics.Float"},{"name":"turns","comment":" Construct an angle from a number of turns.\n\n    Angle.turns -0.25\n    --> Angle.degrees -90\n\n","type":"Basics.Float -> Angle.Angle"}],"binops":[]},{"name":"Units.Area","comment":" An `Area` represents an area in square meters, square feet, acres, hectares\netc. It is stored as a number of square meters.\n\nNote that you can construct an `Area` value directly using the functions in this\nmodule, but it also works to call [`Quantity.squared`](Quantity#squared) on a\n`Length` or [`Quantity.product`](Quantity#product) on a pair of `Length`s. The\nfollowing are all equivalent:\n\n    Area.squareFeet 100\n\n    Quantity.squared (Length.feet 10)\n\n    Quantity.product (Length.feet 25) (Length.feet 4)\n\n@docs Area, SquareMeters\n\n\n## Metric\n\n@docs squareMeters, inSquareMeters\n@docs squareMillimeters, inSquareMillimeters, squareCentimeters, inSquareCentimeters, hectares, inHectares, squareKilometers, inSquareKilometers\n\n\n## Imperial\n\n@docs squareInches, inSquareInches, squareFeet, inSquareFeet, squareYards, inSquareYards, acres, inAcres, squareMiles, inSquareMiles\n\n","unions":[],"aliases":[{"name":"Area","comment":" ","args":[],"type":"Area.Area"},{"name":"SquareMeters","comment":" ","args":[],"type":"Area.SquareMeters"}],"values":[{"name":"acres","comment":" Construct an area from a number of acres.\n","type":"Basics.Float -> Area.Area"},{"name":"hectares","comment":" Construct an area from a number of hectares.\n","type":"Basics.Float -> Area.Area"},{"name":"inAcres","comment":" Convert an area to a number of acres.\n","type":"Area.Area -> Basics.Float"},{"name":"inHectares","comment":" Convert an area to a number of hectares.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareCentimeters","comment":" Convert an area to a number of square centimeters.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareFeet","comment":" Convert an area to a number of square feet.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareInches","comment":" Convert an area to a number of square inches.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareKilometers","comment":" Convert an area to a number of square kilometers.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMeters","comment":" Convert an area to a number of square meters.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMiles","comment":" Convert an area to a number of square miles.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareMillimeters","comment":" Convert an area to a number of square millimeters.\n","type":"Area.Area -> Basics.Float"},{"name":"inSquareYards","comment":" Convert an area to a number of square yards.\n","type":"Area.Area -> Basics.Float"},{"name":"squareCentimeters","comment":" Construct an area from a number of square centimeters.\n","type":"Basics.Float -> Area.Area"},{"name":"squareFeet","comment":" Construct an area from a number of square feet.\n","type":"Basics.Float -> Area.Area"},{"name":"squareInches","comment":" Construct an area from a number of square inches.\n","type":"Basics.Float -> Area.Area"},{"name":"squareKilometers","comment":" Construct an area from a number of square kilometers.\n","type":"Basics.Float -> Area.Area"},{"name":"squareMeters","comment":" Construct an area from a number of square meters.\n","type":"Basics.Float -> Area.Area"},{"name":"squareMiles","comment":" Construct an area from a number of square miles.\n","type":"Basics.Float -> Area.Area"},{"name":"squareMillimeters","comment":" Construct an area from a number of square millimeters.\n","type":"Basics.Float -> Area.Area"},{"name":"squareYards","comment":" Construct an area from a number of square yards.\n","type":"Basics.Float -> Area.Area"}],"binops":[]},{"name":"Units.Charge","comment":" A `Charge` value represents an electrical charge in coulombs or ampere\nhours. It is stored as a number of coulombs.\n\n@docs Charge, Coulombs\n\n@docs coulombs, inCoulombs, ampereHours, inAmpereHours, milliampereHours, inMilliampereHours\n\n","unions":[],"aliases":[{"name":"Charge","comment":" ","args":[],"type":"Charge.Charge"},{"name":"Coulombs","comment":" ","args":[],"type":"Charge.Coulombs"}],"values":[{"name":"ampereHours","comment":" Construct a charge from a number of ampere hours.\n","type":"Basics.Float -> Charge.Charge"},{"name":"coulombs","comment":" Construct a charge from a number of coulombs.\n","type":"Basics.Float -> Charge.Charge"},{"name":"inAmpereHours","comment":" Convert a charge to a number of ampere hours.\n","type":"Charge.Charge -> Basics.Float"},{"name":"inCoulombs","comment":" Convert a charge to a number of coulombs.\n","type":"Charge.Charge -> Basics.Float"},{"name":"inMilliampereHours","comment":" Convert a charge to a number of milliampere hours.\n","type":"Charge.Charge -> Basics.Float"},{"name":"milliampereHours","comment":" Construct a charge from a number of milliampere hours.\n","type":"Basics.Float -> Charge.Charge"}],"binops":[]},{"name":"Units.Current","comment":" A `Current` value represents an electrical current in amperes.\n\nNote that since `Amperes` is defined as `Rate Coulombs Seconds` (charge\nper unit time), you can construct a `Current` value using `Quantity.per`:\n\n    current =\n        charge |> Quantity.per duration\n\nYou can also do rate-related calculations with `Current` values to compute\n`Charge` or `Duration`:\n\n    charge =\n        current |> Quantity.times duration\n\n    alsoCharge =\n        duration |> Quantity.at current\n\n    duration =\n        charge |> Quantity.at_ current\n\n@docs Current, Amperes\n\n@docs amperes, inAmperes, milliamperes, inMilliamperes\n\n","unions":[],"aliases":[{"name":"Amperes","comment":" ","args":[],"type":"Current.Amperes"},{"name":"Current","comment":" ","args":[],"type":"Current.Current"}],"values":[{"name":"amperes","comment":" Construct a current from a number of amperes.\n","type":"Basics.Float -> Current.Current"},{"name":"inAmperes","comment":" Convert a current to a number of amperes.\n\n    Charge.coulombs 10\n        |> Quantity.per (Duration.seconds 2)\n        |> Current.inAmperes\n    --> 5\n\n","type":"Current.Current -> Basics.Float"},{"name":"inMilliamperes","comment":" Convert a current to number of milliamperes.\n\n    Current.amperes 2 |> Current.inMilliamperes\n    --> 2000\n\n","type":"Current.Current -> Basics.Float"},{"name":"milliamperes","comment":" Construct a current from a number of milliamperes.\n\n    Current.milliamperes 500\n    --> Current.amperes 0.5\n\n","type":"Basics.Float -> Current.Current"}],"binops":[]},{"name":"Units.Duration","comment":" A `Duration` refers to an elapsed time in seconds, milliseconds, hours etc.,\nas opposed to a specific instant in time (which would generally be represented\nby a [`Posix`](https://package.elm-lang.org/packages/elm/time/latest/Time#Posix)\nvalue). It is stored as a number of seconds.\n\n@docs Duration, Seconds\n\n@docs from, seconds, inSeconds, milliseconds, inMilliseconds, minutes, inMinutes, hours, inHours, days, inDays, weeks, inWeeks, julianYears, inJulianYears\n\n","unions":[],"aliases":[{"name":"Duration","comment":" ","args":[],"type":"Duration.Duration"},{"name":"Seconds","comment":" ","args":[],"type":"Duration.Seconds"}],"values":[{"name":"days","comment":" Construct a `Duration` from a given number of days. A day is defined as\nexactly 24 hours or 86400 seconds. Therefore, it is only equal to the length of\na given calendar day if that calendar day does not include either a leap second\nor any added/removed daylight savings hours.\n\n    Duration.days 1\n    --> Duration.hours 24\n\n","type":"Basics.Float -> Duration.Duration"},{"name":"from","comment":" Find the elapsed time from a start time to an end time. For example,\nassuming that `nineAM` and `fivePM` are two `Time.Posix` values on the same day:\n\n    Duration.from nineAM fivePM\n    --> Duration.hours 8\n\n","type":"Time.Posix -> Time.Posix -> Duration.Duration"},{"name":"hours","comment":" Construct a `Duration` from a given number of hours.\n\n    Duration.hours 1\n    --> Duration.seconds 3600\n\n","type":"Basics.Float -> Duration.Duration"},{"name":"inDays","comment":" Convert a `Duration` to a value in days.\n\n    Duration.hours 72 |> Duration.inDays\n    --> 3\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inHours","comment":" Convert a `Duration` to a value in hours.\n\n    Duration.minutes 120 |> Duration.inHours\n    --> 2\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inJulianYears","comment":" Convert a `Duration` to a value in Julian years.\n\n    Duration.hours 10000 |> Duration.inJulianYears\n    --> 1.1407711613050422\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inMilliseconds","comment":" Convert a `Duration` to a value in milliseconds.\n\n    Duration.seconds 0.5 |> Duration.inMilliseconds\n    --> 500\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inMinutes","comment":" Convert a `Duration` to a value in minutes.\n\n    Duration.seconds 90 |> Duration.inMinutes\n    --> 1.5\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inSeconds","comment":" Convert a `Duration` to a value in seconds.\n\n    Duration.milliseconds 10 |> Duration.inSeconds\n    --> 0.01\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"inWeeks","comment":" Convert a `Duration` to a value in weeks.\n\n    Duration.days 28 |> Duration.inWeeks\n    --> 4\n\n","type":"Duration.Duration -> Basics.Float"},{"name":"julianYears","comment":" Construct a `Duration` from a given number of [Julian years][julian_year].\nA Julian year is defined as exactly 365.25 days, the average length of a year in\nthe historical Julian calendar. This is 10 minutes and 48 seconds longer than\na Gregorian year (365.2425 days), which is the average length of a year in the\nmodern Gregorian calendar, but the Julian year is a bit easier to remember and\nreason about and has the virtue of being the 'year' value used in the definition\nof a [light year](Length#lightYears).\n\n    Duration.julianYears 1\n    --> Duration.days 365.25\n\n[julian_year]: https://en.wikipedia.org/wiki/Julian_year_(astronomy) \"Julian year\"\n\n","type":"Basics.Float -> Duration.Duration"},{"name":"milliseconds","comment":" Construct a `Duration` from a given number of milliseconds.\n\n    Duration.milliseconds 5000\n    --> Duration.seconds 5\n\n","type":"Basics.Float -> Duration.Duration"},{"name":"minutes","comment":" Construct a `Duration` from a given number of minutes.\n\n    Duration.minutes 3\n    --> Duration.seconds 180\n\n","type":"Basics.Float -> Duration.Duration"},{"name":"seconds","comment":" Construct a `Duration` from a given number of seconds.\n","type":"Basics.Float -> Duration.Duration"},{"name":"weeks","comment":" Construct a `Duration` from a given number of weeks.\n\n    Duration.weeks 1\n    --> Duration.days 7\n\n","type":"Basics.Float -> Duration.Duration"}],"binops":[]},{"name":"Units.Energy","comment":" An `Energy` value represents an amount of energy (or work) in joules,\nkilowatt hours etc. It is stored as a number of joules.\n\n@docs Energy, Joules\n\n@docs joules, inJoules, kilojoules, inKilojoules, megajoules, inMegajoules, kilowattHours, inKilowattHours\n\n","unions":[],"aliases":[{"name":"Energy","comment":" ","args":[],"type":"Energy.Energy"},{"name":"Joules","comment":" ","args":[],"type":"Energy.Joules"}],"values":[{"name":"inJoules","comment":" Convert an energy value to a number of joules.\n","type":"Energy.Energy -> Basics.Float"},{"name":"inKilojoules","comment":" Convert an energy value to a number of kilojoules.\n","type":"Energy.Energy -> Basics.Float"},{"name":"inKilowattHours","comment":" Convert an energy value to a number of kilowatt hours.\n","type":"Energy.Energy -> Basics.Float"},{"name":"inMegajoules","comment":" Convert an energy value to a number of megajoules.\n","type":"Energy.Energy -> Basics.Float"},{"name":"joules","comment":" Construct an energy value from a number of joules.\n","type":"Basics.Float -> Energy.Energy"},{"name":"kilojoules","comment":" Construct an energy value from a number of kilojoules.\n","type":"Basics.Float -> Energy.Energy"},{"name":"kilowattHours","comment":" Construct an energy value from a number of kilowatt hours.\n\n    Energy.kilowattHours 1\n    --> Energy.megajoules 3.6\n\n","type":"Basics.Float -> Energy.Energy"},{"name":"megajoules","comment":" Construct an energy value from a number of megajoules.\n","type":"Basics.Float -> Energy.Energy"}],"binops":[]},{"name":"Units.Force","comment":" A `Force` value represents a force in newtons, pounds force etc. It is\nstored as a number of newtons.\n\nNote that since `Newtons` is defined as `Rate Joules Meters` (energy/work per\nunit length), you can do things like compute work as a product of force and\ndistance:\n\n    work =\n        force |> Quantity.times length\n\n@docs Force, Newtons\n\n\n## Metric\n\n@docs newtons, inNewtons, kilonewtons, inKilonewtons, meganewtons, inMeganewtons\n\n\n## Imperial\n\n@docs pounds, inPounds, kips, inKips\n\n","unions":[],"aliases":[{"name":"Force","comment":" ","args":[],"type":"Force.Force"},{"name":"Newtons","comment":" ","args":[],"type":"Force.Newtons"}],"values":[{"name":"inKilonewtons","comment":" Convert a force value to a number of kilonewtons.\n","type":"Force.Force -> Basics.Float"},{"name":"inKips","comment":" Convert a force value to a number of kips.\n","type":"Force.Force -> Basics.Float"},{"name":"inMeganewtons","comment":" Convert a force value to a number of meganewtons.\n","type":"Force.Force -> Basics.Float"},{"name":"inNewtons","comment":" Convert a force value to a number of newtons.\n","type":"Force.Force -> Basics.Float"},{"name":"inPounds","comment":" Convert a force value to a number of pounds force.\n","type":"Force.Force -> Basics.Float"},{"name":"kilonewtons","comment":" Construct a force value from a number of kilonewtons.\n","type":"Basics.Float -> Force.Force"},{"name":"kips","comment":" Construct a force value from a number of kips (kilopounds force).\n\n    Force.kips 2\n    --> Force.pounds 2000\n\n","type":"Basics.Float -> Force.Force"},{"name":"meganewtons","comment":" Construct a force value from a number of meganewtons.\n","type":"Basics.Float -> Force.Force"},{"name":"newtons","comment":" Construct a force value from a number of newtons.\n","type":"Basics.Float -> Force.Force"},{"name":"pounds","comment":" Construct a force value from a number of pounds force. One pound force is\nthe force required to accelerate one [pound mass][1] at a rate of [one gee][2].\n\n[1]: Mass#pounds\n[2]: Acceleration#gees\n\n","type":"Basics.Float -> Force.Force"}],"binops":[]},{"name":"Units.Length","comment":" A `Length` represents a length in meters, feet, centimeters, miles etc. It\nis stored as a number of meters.\n\n@docs Length, Meters\n\n\n## Metric\n\n@docs meters, inMeters\n@docs microns, inMicrons, millimeters, inMillimeters, centimeters, inCentimeters, kilometers, inKilometers\n\n\n## Imperial\n\n@docs thou, inThou, inches, inInches, feet, inFeet, yards, inYards, miles, inMiles\n\n\n## Astronomical\n\n@docs astronomicalUnits, inAstronomicalUnits, parsecs, inParsecs, lightYears, inLightYears\n\n","unions":[],"aliases":[{"name":"Length","comment":" ","args":[],"type":"Length.Length"},{"name":"Meters","comment":" ","args":[],"type":"Length.Meters"}],"values":[{"name":"astronomicalUnits","comment":" Construct a length from a number of [astronomical units][au] (AU). One AU is\napproximately equal to the average distance of the Earth from the Sun.\n\n[au]: https://en.wikipedia.org/wiki/Astronomical_unit \"Astronomical unit\"\n\n","type":"Basics.Float -> Length.Length"},{"name":"centimeters","comment":" Construct a length from a number of centimeters.\n","type":"Basics.Float -> Length.Length"},{"name":"feet","comment":" Construct a length from a number of feet.\n","type":"Basics.Float -> Length.Length"},{"name":"inAstronomicalUnits","comment":" Convert a length to a number of astronomical units.\n","type":"Length.Length -> Basics.Float"},{"name":"inCentimeters","comment":" Convert a length to a number of centimeters.\n","type":"Length.Length -> Basics.Float"},{"name":"inFeet","comment":" Convert a length to a number of feet.\n","type":"Length.Length -> Basics.Float"},{"name":"inInches","comment":" Convert a length to a number of inches.\n","type":"Length.Length -> Basics.Float"},{"name":"inKilometers","comment":" Convert a length to a number of kilometers.\n","type":"Length.Length -> Basics.Float"},{"name":"inLightYears","comment":" Convert a length to a number of light years.\n","type":"Length.Length -> Basics.Float"},{"name":"inMeters","comment":" Convert a length to a number of meters.\n\n    Length.feet 1 |> Length.inMeters\n    --> 0.3048\n\n","type":"Length.Length -> Basics.Float"},{"name":"inMicrons","comment":" Convert a length to a number of microns (micrometers).\n\n    Length.millimeters 1 |> Length.inMicrons\n    --> 1000\n\n","type":"Length.Length -> Basics.Float"},{"name":"inMiles","comment":" Convert a length to a number of miles.\n","type":"Length.Length -> Basics.Float"},{"name":"inMillimeters","comment":" Convert a length to number of millimeters.\n","type":"Length.Length -> Basics.Float"},{"name":"inParsecs","comment":" Convert a length to a number of parsecs.\n","type":"Length.Length -> Basics.Float"},{"name":"inThou","comment":" Convert a length to a number of thou (thousandths of an inch).\n\n    Length.millimeters 1 |> Length.inThou\n    --> 39.37007874015748\n\n","type":"Length.Length -> Basics.Float"},{"name":"inYards","comment":" Convert a length to a number of yards.\n","type":"Length.Length -> Basics.Float"},{"name":"inches","comment":" Construct a length from a number of inches.\n","type":"Basics.Float -> Length.Length"},{"name":"kilometers","comment":" Construct a length from a number of kilometers.\n","type":"Basics.Float -> Length.Length"},{"name":"lightYears","comment":" Construct a length from a number of light years. One light year is the\ndistance traveled when moving at the speed of light for one [Julian year](Duration#julianYear).\n","type":"Basics.Float -> Length.Length"},{"name":"meters","comment":" Construct a length from a number of meters.\n\n    height : Length\n    height =\n        Length.meters 2\n\n","type":"Basics.Float -> Length.Length"},{"name":"microns","comment":" Construct a length from a number of microns (micrometers).\n\n    Length.microns 1\n    --> Length.meters 1e-6\n\n","type":"Basics.Float -> Length.Length"},{"name":"miles","comment":" Construct a length from a number of miles.\n","type":"Basics.Float -> Length.Length"},{"name":"millimeters","comment":" Construct a length from number of millimeters.\n","type":"Basics.Float -> Length.Length"},{"name":"parsecs","comment":" Construct a length from a number of [parsecs][parsec].\n\n[parsec]: https://en.wikipedia.org/wiki/Parsec \"Parsec\"\n\n","type":"Basics.Float -> Length.Length"},{"name":"thou","comment":" Construct a length from a number of thou (thousandths of an inch).\n\n    Length.thou 5\n    --> Length.inches 0.005\n\n","type":"Basics.Float -> Length.Length"},{"name":"yards","comment":" Construct a length from a number of yards.\n","type":"Basics.Float -> Length.Length"}],"binops":[]},{"name":"Units.Mass","comment":" A `Mass` represents a mass in kilograms, pounds, metric or imperial tons\netc. It is stored as a number of kilograms.\n\n@docs Mass, Kilograms\n\n\n## Metric\n\n@docs kilograms, inKilograms, grams, inGrams, metricTons, inMetricTons\n\n\n## Imperial\n\n@docs pounds, inPounds, ounces, inOunces, longTons, inLongTons\n\n\n## U.S. customary\n\n@docs shortTons, inShortTons\n\n","unions":[],"aliases":[{"name":"Kilograms","comment":" ","args":[],"type":"Mass.Kilograms"},{"name":"Mass","comment":" ","args":[],"type":"Mass.Mass"}],"values":[{"name":"grams","comment":" Construct a mass from a number of grams.\n","type":"Basics.Float -> Mass.Mass"},{"name":"inGrams","comment":" Convert a mass to a number of grams.\n","type":"Mass.Mass -> Basics.Float"},{"name":"inKilograms","comment":" Convert a mass to a number of kilograms.\n","type":"Mass.Mass -> Basics.Float"},{"name":"inLongTons","comment":" Convert a mass to a number of long tons.\n","type":"Mass.Mass -> Basics.Float"},{"name":"inMetricTons","comment":" Convert a mass to a number of metric tons.\n","type":"Mass.Mass -> Basics.Float"},{"name":"inOunces","comment":" Convert a mass to a number of ounces.\n\n    Mass.pounds 1 |> Mass.inOunces\n    --> 16\n\n","type":"Mass.Mass -> Basics.Float"},{"name":"inPounds","comment":" Convert a mass to a number of pounds.\n","type":"Mass.Mass -> Basics.Float"},{"name":"inShortTons","comment":" Convert a mass to a number of short tons.\n","type":"Mass.Mass -> Basics.Float"},{"name":"kilograms","comment":" Construct a mass from a number of kilograms.\n","type":"Basics.Float -> Mass.Mass"},{"name":"longTons","comment":" Construct a mass from a number of [long tons][1]. This is the 'ton' commonly\nused in the United Kingdom and British Commonwealth.\n\n    Mass.longTons 1\n    --> Mass.pounds 2240\n\n[1]: https://en.wikipedia.org/wiki/Long_ton\n\n","type":"Basics.Float -> Mass.Mass"},{"name":"metricTons","comment":" Construct a mass from a number of [metric tons][1].\n\n    Mass.metricTons 1\n    --> Mass.kilograms 1000\n\n[1]: https://en.wikipedia.org/wiki/Tonne\n\n","type":"Basics.Float -> Mass.Mass"},{"name":"ounces","comment":" Construct a mass from a number of ounces.\n","type":"Basics.Float -> Mass.Mass"},{"name":"pounds","comment":" Construct a mass from a number of pounds.\n","type":"Basics.Float -> Mass.Mass"},{"name":"shortTons","comment":" Construct a mass from a number of [short tons][1]. This is the 'ton'\ncommonly used in the United States.\n\n    Mass.shortTons 1\n    --> Mass.pounds 2000\n\n[1]: https://en.wikipedia.org/wiki/Short_ton\n\n","type":"Basics.Float -> Mass.Mass"}],"binops":[]},{"name":"Units.Pixels","comment":" Although most of the focus of `elm-units` is on physical/scientific units,\nit's very useful to be able to safely convert back and forth between (for\nexample) [`Length`](Length) values in the real world and on-screen lengths in\npixels. This module provides a standard `Pixels` units type and basic functions\nfor constructing/converting values of type `Quantity number Pixels`, which\nallows you to do things like represent conversions between real-world and\non-screen lengths as [rates of change][1]. This in turn means that all the\nnormal `Quantity` functions can be used to convert between pixels and other\nunits, or even do type-safe math directly on pixel values.\n\n[1]: Quantity#working-with-rates\n\n@docs Pixels, PixelsPerSecond, PixelsPerSecondSquared, SquarePixels\n\n@docs pixels, inPixels\n\n@docs pixelsPerSecond, inPixelsPerSecond\n\n@docs pixelsPerSecondSquared, inPixelsPerSecondSquared\n\n@docs squarePixels, inSquarePixels\n\n","unions":[],"aliases":[{"name":"Pixels","comment":" Units type representing one on-screen pixel.\n","args":[],"type":"Pixels.Pixels"},{"name":"PixelsPerSecond","comment":" Units type representing an on-screen speed of one pixel per second.\n","args":[],"type":"Pixels.PixelsPerSecond"},{"name":"PixelsPerSecondSquared","comment":" Units type representing an on-screen acceleration of one pixel per second\nsquared.\n","args":[],"type":"Pixels.PixelsPerSecondSquared"},{"name":"SquarePixels","comment":" Units type representing an on-screen area of one square pixel. For example,\na 32x32 image has an area of 1024 square pixels.\n","args":[],"type":"Pixels.SquarePixels"}],"values":[{"name":"inPixels","comment":" Convert a `Pixels` value to a plain number of pixels.\n\n    pixelDensity =\n        pixels 96 |> Quantity.per (Length.inches 1)\n\n    Length.centimeters 1\n        |> Quantity.at pixelDensity\n        |> inPixels\n    --> 37.795275590551185\n\n","type":"Quantity.Quantity number Pixels.Pixels -> number"},{"name":"inPixelsPerSecond","comment":" Convert an on-screen speed to a number of pixels per second.\n\n    elapsedTime =\n        Duration.milliseconds 16\n\n    dragDistance =\n        pixels 2\n\n    dragSpeed =\n        dragDistance |> Quantity.per elapsedTime\n\n    dragSpeed |> inPixelsPerSecond\n    --> 125\n\n","type":"Quantity.Quantity Basics.Float Pixels.PixelsPerSecond -> Basics.Float"},{"name":"inPixelsPerSecondSquared","comment":" Convert an on-screen acceleration to a number of pixels per second squared.\n","type":"Quantity.Quantity Basics.Float Pixels.PixelsPerSecondSquared -> Basics.Float"},{"name":"inSquarePixels","comment":" Convert an on-screen area to a number of square pixels.\n\n    Quantity.product (pixels 1920) (pixels 1080)\n        |> inSquarePixels\n    --> 2073600\n\n","type":"Quantity.Quantity number Pixels.SquarePixels -> number"},{"name":"pixels","comment":" Construct a quantity representing a given number of on-screen pixels:\n\n    screenWidth =\n        pixels 1920\n\nNote that passing an `Int` will give you a\n\n    Quantity Int Pixels\n\nwhile passing a `Float` will give you a\n\n    Quantity Float Pixels\n\nIf you pass a _literal_ integer like `1920`, the result can be used as either an\n`Int` _or_ `Float` number of pixels.\n\n","type":"number -> Quantity.Quantity number Pixels.Pixels"},{"name":"pixelsPerSecond","comment":" Construct an on-screen speed from a number of pixels per second.\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Pixels.PixelsPerSecond"},{"name":"pixelsPerSecondSquared","comment":" Construct an on-screen acceleration from a number of pixels per second\nsquared.\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Pixels.PixelsPerSecondSquared"},{"name":"squarePixels","comment":" Construct an on-screen area from a number of square pixels.\n","type":"number -> Quantity.Quantity number Pixels.SquarePixels"}],"binops":[]},{"name":"Units.Power","comment":" A `Power` value represents power in watts or horsepower. It is stored as a\nnumber of watts.\n\nNote that since `Watts` is defined as `Rate Joules Seconds` (energy per unit\ntime), you can construct a `Power` value using `Quantity.per`:\n\n    power =\n        energy |> Quantity.per duration\n\nYou can also do rate-related calculations with `Power` values to compute\n`Energy` or `Duration`:\n\n    energy =\n        power |> Quantity.times duration\n\n    alsoEnergy =\n        duration |> Quantity.at power\n\n    duration =\n        energy |> Quantity.at_ power\n\n[1]: https://en.wikipedia.org/wiki/Horsepower#Definitions\n\n@docs Power, Watts\n\n\n## Watts\n\n@docs watts, inWatts, kilowatts, inKilowatts, megawatts, inMegawatts\n\n\n## Horsepower\n\nWho knew that there were not one, not two, but _three_ possible interpretations\nof \"one horsepower\"? (Actually there are more than that, but these three\nseemed the most reasonable.)\n\n@docs metricHorsepower, inMetricHorsepower, mechanicalHorsepower, inMechanicalHorsepower, electricalHorsepower, inElectricalHorsepower\n\n","unions":[],"aliases":[{"name":"Power","comment":" ","args":[],"type":"Power.Power"},{"name":"Watts","comment":" ","args":[],"type":"Power.Watts"}],"values":[{"name":"electricalHorsepower","comment":" Construct a `Power` value from an number of [electrical horsepower][1].\n\n    Power.electricalHorsepower 1\n    --> Power.watts 746\n\n[1]: https://en.wikipedia.org/wiki/Horsepower#Electrical_horsepower\n\n","type":"Basics.Float -> Power.Power"},{"name":"inElectricalHorsepower","comment":" Convert a `Power` value to a number of electrical horsepower.\n","type":"Power.Power -> Basics.Float"},{"name":"inKilowatts","comment":" Convert a `Power` value to a number of kilowatts.\n","type":"Power.Power -> Basics.Float"},{"name":"inMechanicalHorsepower","comment":" Convert a `Power` value to a number of mechanical horsepower.\n","type":"Power.Power -> Basics.Float"},{"name":"inMegawatts","comment":" Convert a `Power` value to a number of megawatts.\n","type":"Power.Power -> Basics.Float"},{"name":"inMetricHorsepower","comment":" Convert a `Power` value to a number of metric horsepower.\n","type":"Power.Power -> Basics.Float"},{"name":"inWatts","comment":" Convert a `Power` value to a number of watts.\n","type":"Power.Power -> Basics.Float"},{"name":"kilowatts","comment":" Construct a `Power` value from a number of kilowatts.\n","type":"Basics.Float -> Power.Power"},{"name":"mechanicalHorsepower","comment":" Construct a `Power` value from an number of [mechanical horsepower][1].\n\n    Power.mechanicalHorsepower 1\n    --> Power.watts 745.6998715822702\n\n[1]: https://en.wikipedia.org/wiki/Horsepower#Mechanical_horsepower\n\n","type":"Basics.Float -> Power.Power"},{"name":"megawatts","comment":" Construct a `Power` value from a number of megawatts.\n","type":"Basics.Float -> Power.Power"},{"name":"metricHorsepower","comment":" Construct a `Power` value from an number of [metric horsepower][1].\n\n    Power.metricHorsepower 1\n    --> Power.watts 735.49875\n\n[1]: https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower\n\n","type":"Basics.Float -> Power.Power"},{"name":"watts","comment":" Construct a `Power` value from a number of watts.\n","type":"Basics.Float -> Power.Power"}],"binops":[]},{"name":"Units.Pressure","comment":" A `Pressure` value represents a pressure in kilopascals, pounds per square\ninch, [atmospheres][1] etc. It is stored as a number of pascals.\n\nNote that since `Pascals` is defined as `Rate Newtons SquareMeters` (force per\nunit area), you can construct a `Pressure` value using `Quantity.per`:\n\n    pressure =\n        force |> Quantity.per area\n\nYou can also do rate-related calculations with `Pressure` values to compute\n`Force` or `Area`:\n\n    force =\n        pressure |> Quantity.times area\n\n    alsoForce =\n        area |> Quantity.at pressure\n\n    area =\n        force |> Quantity.at_ pressure\n\n[1]: https://en.wikipedia.org/wiki/Atmosphere_(unit)\n\n@docs Pressure, Pascals\n\n@docs pascals, inPascals, kilopascals, inKilopascals, megapascals, inMegapascals, poundsPerSquareInch, inPoundsPerSquareInch, atmospheres, inAtmospheres\n\n","unions":[],"aliases":[{"name":"Pascals","comment":" ","args":[],"type":"Pressure.Pascals"},{"name":"Pressure","comment":" ","args":[],"type":"Pressure.Pressure"}],"values":[{"name":"atmospheres","comment":" Construct a pressure from a number of [atmospheres][1].\n\n[1]: https://en.wikipedia.org/wiki/Atmosphere_(unit)\n\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"inAtmospheres","comment":" Convert a pressure to a number of atmospheres.\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inKilopascals","comment":" Convert a pressure to a number of kilopascals.\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inMegapascals","comment":" Convert a pressure to a number of megapascals.\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inPascals","comment":" Convert a pressure to a number of pascals.\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"inPoundsPerSquareInch","comment":" Convert a pressure to a number of pounds per square inch.\n","type":"Pressure.Pressure -> Basics.Float"},{"name":"kilopascals","comment":" Construct a pressure from a number of kilopascals.\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"megapascals","comment":" Construct a pressure from a number of megapascals.\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"pascals","comment":" Construct a pressure from a number of pascals.\n","type":"Basics.Float -> Pressure.Pressure"},{"name":"poundsPerSquareInch","comment":" Construct a pressure from a number of pounds per square inch.\n","type":"Basics.Float -> Pressure.Pressure"}],"binops":[]},{"name":"Units.Quantity","comment":"\n\n@docs Quantity\n\n\n# Unit types\n\nThe `Squared` and `Rate` units types allow you to build up and work with\ncomposite units in a fairly flexible way.\n\n@docs Squared, Rate\n\n\n# Constants\n\n@docs zero, infinity, positiveInfinity, negativeInfinity\n\n\n# Comparison\n\n@docs lessThan, greaterThan, compare, equalWithin, max, min, isNaN, isInfinite\n\n\n# Arithmetic\n\n@docs negate, plus, minus, product, ratio, scaleBy, divideBy, abs, clamp, squared, sqrt\n\n\n# `Int`/`Float` conversion\n\nThese functions only really make sense for quantities in units like pixels,\ncents or game tiles where an `Int` number of units is meaningful. For quantities\nlike `Length` or `Duration`, it doesn't really make sense to round to an `Int`\nvalue since the underyling base unit is pretty arbitrary - should `round`ing a\n`Duration` give you an `Int` number of seconds, milliseconds, or something else?\n\n@docs round, floor, ceiling, truncate, toFloatQuantity\n\n\n# List functions\n\nThese functions act just like the corresponding functions in the built-in `List`\nmodule. They're necessary because the built-in `List.sum` only supports `List\nInt` and `List Float`, and `minimum`/`maximum`/`sort` only support built-in\ncomparable types like `Int`, `Float`, `String` and tuples.\n\n@docs sum, minimum, maximum, sort\n\n\n# Working with rates\n\n@docs per, times, at, at_, inverse\n\n\n# Unitless quantities\n\nIt is sometimes useful to be able to represent _unitless_ quantities, especially\nwhen working with generic code (in most other cases, it is likely simpler and\neasier to just use `Int` or `Float` values directly). All the conversions in\nthis section simply wrap or unwrap a `Float` or `Int` value into a `Quantity`\nvalue, and so should get compiled away entirely when using `elm make\n--optimize`.\n\n@docs Unitless, int, toInt, float, toFloat\n\n","unions":[],"aliases":[{"name":"Quantity","comment":" A `Quantity` is effectively a `number` (an `Int` or `Float`) tagged with a\n`units` type. So a\n\n    Quantity Float Meters\n\nis a `Float` number of `Meters` and a\n\n    Quantity Int Pixels\n\nis an `Int` number of `Pixels`. When compiling with `elm make --optimize` the\n`Quantity` wrapper type will be compiled away, so the runtime performance should\nbe comparable to using a raw `Float` or `Int`.\n\n","args":["number","units"],"type":"Quantity.Quantity number units"},{"name":"Rate","comment":" Represents the units type of a rate or quotient such as a speed (`Rate\nMeters Seconds`) or a pressure (`Rate Newtons SquareMeters`). As with `Squared`,\nthere are several functions that \"know\" about the `Rate` units type and how to\nwork with it - see [Working with rates](#working-with-rates) for details.\n","args":["dependentUnits","independentUnits"],"type":"Quantity.Rate dependentUnits independentUnits"},{"name":"Squared","comment":" Represents a units type that is the square of some other units type; for\nexample, `Meters` is one units type (the units type of a `Length`) and `Squared\nMeters` is another (the units type of an `Area`). This is useful because some\nfunctions in this module (specifically [`product`](#product),\n[`squared`](#squared), and [`sqrt`](#sqrt)) \"know\" about the `Squared` type and\nhow to work with it.\n","args":["units"],"type":"Quantity.Squared units"},{"name":"Unitless","comment":" A special units type representing 'no units'. A `Quantity Int Unitless`\nvalue is interchangeable with a simple `Int`, and a `Quantity Float Unitless`\nvalue is interchangeable with a simple `Float`.\n","args":[],"type":"Quantity.Unitless"}],"values":[{"name":"abs","comment":" Get the absolute value of a quantity.\n\n    Quantity.abs (Duration.milliseconds -10)\n    --> Duration.milliseconds 10\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"at","comment":" Same as `times` but with the argument order flipped, which may read better\nin some cases:\n\n    Duration.minutes 30\n        |> Quantity.at\n            (Speed.kilometersPerHour 100)\n    --> Length.kilometers 50\n\nCan be useful to define conversion functions from one unit to another, since\nif you define a `rate` then `Quantity.at rate` will give you a conversion\nfunction:\n\n    pixelDensity : Quantity Float (Rate Pixels Meters)\n    pixelDensity =\n        Pixels.pixels 96 |> Quantity.per (Length.inches 1)\n\n    lengthToPixels : Length -> Quantity Float Pixels\n    lengthToPixels length =\n        Quantity.at pixelDensity length\n\n    lengthToPixels (Length.inches 3)\n    --> Pixels.pixels 288\n\nEagle-eyed readers will note that using partial application you could also\nsimply write\n\n    lengthToPixels =\n        Quantity.at pixelDensity\n\n","type":"Quantity.Quantity number (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity number independentUnits -> Quantity.Quantity number dependentUnits"},{"name":"at_","comment":" Given a rate and a _dependent_ value, determine the necessary amount of the\n_independent_ value:\n\n    Length.kilometers 75\n        |> Quantity.at_\n            (Speed.kilometersPerHour 100)\n    --> Duration.minutes 45\n\nWhere `times` and `at` perform multiplication, `at_` performs division - you\nmultiply a speed by a duration to get a distance, but you divide a distance by\na speed to get a duration.\n\nSimilar to `at`, `at_` can be used to define an _inverse_ conversion function:\n\n    pixelDensity : Quantity Float (Rate Pixels Meters)\n    pixelDensity =\n        Pixels.pixels 96 |> Quantity.per (Length.inches 1)\n\n    pixelsToLength : Quantity Float Pixels -> Length\n    pixelsToLength pixels =\n        Quantity.at_ pixelDensity pixels\n\n    pixelsToLength (Pixels.pixels 48)\n    --> Length.inches 0.5\n\n","type":"Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity Basics.Float dependentUnits -> Quantity.Quantity Basics.Float independentUnits"},{"name":"ceiling","comment":" Round a `Float`-valued quantity up to the nearest `Int`.\n\n    Quantity.ceiling (Pixels.pixels 1.2)\n    --> Pixels.pixels 2\n\n    Quantity.ceiling (Pixels.pixels -2.1)\n    --> Pixels.pixels -2\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"clamp","comment":" Given a lower and upper bound, clamp a given quantity to within those\nbounds. Say you wanted to clamp an angle to be between +/-30 degrees:\n\n    lowerBound =\n        Angle.degrees -30\n\n    upperBound =\n        Angle.degrees 30\n\n    Quantity.clamp lowerBound upperBound (Angle.degrees 5)\n    --> Angle.degrees 5\n\n    -- One radian is approximately 57 degrees\n    Quantity.clamp lowerBound upperBound (Angle.radians 1)\n    --> Angle.degrees 30\n\n    Quantity.clamp lowerBound upperBound (Angle.turns -0.5)\n    --> Angle.degrees -30\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"compare","comment":" Compare two quantities, returning an [`Order`](https://package.elm-lang.org/packages/elm/core/latest/Basics#Order)\nvalue indicating whether the first is less than, equal to or greater than the\nsecond.\n\n    Quantity.compare (Duration.minutes 90) (Duration.hours 1)\n    --> GT\n\n    Quantity.compare (Duration.minutes 60) (Duration.hours 1)\n    --> EQ\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Order"},{"name":"divideBy","comment":" Divide a `Quantity` by a `Float`.\n\n    Quantity.divideBy 2 (Duration.hours 1)\n    --> Duration.minutes 30\n\n","type":"Basics.Float -> Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units"},{"name":"equalWithin","comment":" Check if two quantities are equal within a given absolute tolerance. The\ngiven tolerance must be greater than or equal to zero - if it is negative, then\nthe result will always be false.\n\n    -- 3 feet is 91.44 centimeters or 0.9144 meters\n\n    Quantity.equalWithin (Length.centimeters 10)\n        (Length.meters 1)\n        (Length.feet 3)\n    --> True\n\n    Quantity.equalWithin (Length.centimeters 5)\n        (Length.meters 1)\n        (Length.feet 3)\n    --> False\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"float","comment":" Convert a plain `Float` into a `Quantity Float Unitless` value.\n","type":"Basics.Float -> Quantity.Quantity Basics.Float Quantity.Unitless"},{"name":"floor","comment":" Round a `Float`-valued quantity down to the nearest `Int`.\n\n    Quantity.floor (Pixels.pixels 2.9)\n    --> Pixels.pixels 2\n\n    Quantity.floor (Pixels.pixels -2.1)\n    --> Pixels.pixels -3\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"greaterThan","comment":" Check if one quantity is greater than another. Note the [argument order](/#argument-order)!\n\n    oneMeter =\n        Length.meters 1\n\n    Length.feet 1 |> Quantity.greaterThan oneMeter\n    --> False\n\n    -- Same as:\n    Quantity.greaterThan oneMeter (Length.feet 1)\n    --> False\n\n    List.filter (Quantity.greaterThan oneMeter)\n        [ Length.feet 1\n        , Length.parsecs 1\n        , Length.yards 1\n        , Length.lightYears 1\n        ]\n    --> [ Length.parsecs 1, Length.lightYears 1 ]\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"infinity","comment":" Alias for `positiveInfinity`.\n","type":"Quantity.Quantity Basics.Float units"},{"name":"int","comment":" Convert a plain `Int` into a `Quantity Int Unitless` value.\n","type":"Basics.Int -> Quantity.Quantity Basics.Int Quantity.Unitless"},{"name":"inverse","comment":" Find the inverse of a given rate. May be useful if you are using a rate to\ndefine a conversion, and want to convert the other way;\n\n    Quantity.at (Quantity.inverse rate)\n\nis equivalent to\n\n    Quantity.at_ rate\n\n","type":"Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity Basics.Float (Quantity.Rate independentUnits dependentUnits)"},{"name":"isInfinite","comment":" Check if a quantity is positive or negative infinity.\n\n    Quantity.isInfinite\n        (Length.meters 1\n            |> Quantity.per (Duration.seconds 0)\n        )\n    --> True\n\n    Quantity.isInfinite Quantity.negativeInfinity\n    --> True\n\n","type":"Quantity.Quantity Basics.Float units -> Basics.Bool"},{"name":"isNaN","comment":" Check if a quantity's underlying value is NaN (not-a-number).\n\n    Quantity.isNan (Quantity.sqrt (Area.squareMeters -4))\n    --> True\n\n    Quantity.isNan (Quantity.sqrt (Area.squareMeters 4))\n    --> False\n\n","type":"Quantity.Quantity Basics.Float units -> Basics.Bool"},{"name":"lessThan","comment":" Check if one quantity is less than another. Note the [argument order](/#argument-order)!\n\n    oneMeter =\n        Length.meters 1\n\n    Length.feet 1 |> Quantity.lessThan oneMeter\n    --> True\n\n    -- Same as:\n    Quantity.lessThan oneMeter (Length.feet 1)\n    --> True\n\n    List.filter (Quantity.lessThan oneMeter)\n        [ Length.feet 1\n        , Length.parsecs 1\n        , Length.yards 1\n        , Length.lightYears 1\n        ]\n    --> [ Length.feet 1, Length.yards 1 ]\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Basics.Bool"},{"name":"max","comment":" Find the maximum of two quantities.\n\n    Quantity.max (Duration.hours 2) (Duration.minutes 100)\n    --> Duration.hours 2\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"maximum","comment":" Find the maximum value in a list of quantities. Returns `Nothing` if the\nlist is empty.\n\n    Quantity.maximum\n        [ Mass.kilograms 1\n        , Mass.pounds 2\n        , Mass.tonnes 3\n        ]\n    --> Just (Mass.tonnes 3)\n\n","type":"List.List (Quantity.Quantity number units) -> Maybe.Maybe (Quantity.Quantity number units)"},{"name":"min","comment":" Find the minimum of two quantities.\n\n    Quantity.min (Duration.hours 2) (Duration.minutes 100)\n    --> Duration.minutes 100\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"minimum","comment":" Find the minimum value in a list of quantities. Returns `Nothing` if the\nlist is empty.\n\n    Quantity.minimum\n        [ Mass.kilograms 1\n        , Mass.pounds 2\n        , Mass.tonnes 3\n        ]\n    --> Just (Mass.pounds 2)\n\n","type":"List.List (Quantity.Quantity number units) -> Maybe.Maybe (Quantity.Quantity number units)"},{"name":"minus","comment":" Subtract one quantity from another. Note the [argument order](/#argument-order)!\n\n    fifteenMinutes =\n        Duration.minutes 15\n\n    Duration.hours 1 |> Quantity.minus fifteenMinutes\n    --> Duration.minutes 45\n\n    -- Same as:\n    Quantity.minus fifteenMinutes (Duration.hours 1)\n    --> Duration.minutes 45\n\n    List.map (Quantity.minus fifteenMinutes)\n        [ Duration.hours 1\n        , Duration.hours 2\n        , Duration.minutes 30\n        ]\n    --> [ Duration.minutes 45\n    --> , Duration.minutes 105\n    --> , Duration.minutes 15\n    --> ]\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"negate","comment":" Negate a quantity!\n\n    Quantity.negate (Length.millimeters 10)\n    --> Length.millimeters -10\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"negativeInfinity","comment":" A generic negative infinity value.\n","type":"Quantity.Quantity Basics.Float units"},{"name":"per","comment":" Construct a rate of change by dividing a dependent quantity (numerator) by\nan independent quantity (denominator):\n\n    distance =\n        Length.miles 1\n\n    time =\n        Duration.minutes 1\n\n    speed =\n        distance |> Quantity.per time\n\n    speed |> Speed.inMilesPerHour\n    --> 60\n\nNote that we could directly use our rate of change value as a `Speed`! That is\nbecause many built-in quantity types are defined as rates of change, for\nexample:\n\n  - `Speed` is `Length` per `Duration`\n  - `Acceleration` is `Speed` per `Duration`\n  - `Pressure` is `Force` per `Area`\n  - `Power` is `Energy` per `Duration`\n  - `Force` is `Energy` per `Length`\n  - `Current` is `Charge` per `Duration`\n  - `Voltage` is `Power` per `Current`\n  - `Resistance` is `Voltage` per `Current`\n\n","type":"Quantity.Quantity Basics.Float independentUnits -> Quantity.Quantity Basics.Float dependentUnits -> Quantity.Quantity Basics.Float (Quantity.Rate dependentUnits independentUnits)"},{"name":"plus","comment":" Add two quantities.\n\n    Length.meters 1 |> Quantity.plus (Length.centimeters 5)\n    --> Length.centimeters 105\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"positiveInfinity","comment":" A generic positive infinity value.\n","type":"Quantity.Quantity Basics.Float units"},{"name":"product","comment":" Multiply two quantities with the same `units` together, resulting in a\nquantity in `Squared units`.\n\nThis works for any units type (which is useful when used with [`sqrt`](#sqrt)!)\nbut one special case is worth pointing out. The units type of an [`Area`](Area)\nis `SquareMeters`, which is a type alias for `Squared Meters`. This means that\nthe product of two `Length`s does in fact give you an `Area`:\n\n    Quantity.product\n        (Length.meters 2)\n        (Length.centimeters 40)\n    --> Area.squareMeters 0.8\n\n    -- This is the definition of an acre, I kid you not 😈\n    Quantity.product (Length.feet 66) (Length.feet 660)\n    --> Area.acres 1\n\nNote that there are [other forms of multiplication](/#multiplication)!\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Squared units)"},{"name":"ratio","comment":" Find the ratio of two quantities with the same units.\n\n    Quantity.ratio (Length.miles 1) (Length.yards 1)\n    --> 1760\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Basics.Float"},{"name":"round","comment":" Round a `Float`-valued quantity to the nearest `Int`.\n\n    Quantity.round (Pixels.pixels 3.5)\n    --> Pixels.pixels 4\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"scaleBy","comment":" Multiply a `Quantity` by a `number`.\n\n    Quantity.scaleBy 1.5 (Duration.hours 1)\n    --> Duration.minutes 90\n\nNote that there are [other forms of multiplication](/#multiplication)!\n\n","type":"number -> Quantity.Quantity number units -> Quantity.Quantity number units"},{"name":"sort","comment":" Sort a list of quantities.\n\n    Quantity.sort\n        [ Mass.kilograms 1\n        , Mass.pounds 2\n        , Mass.tonnes 3\n        ]\n    --> [ Mass.pounds 2\n    --> , Mass.kilograms 1\n    --> , Mass.tonnes 3\n    --> ]\n\n","type":"List.List (Quantity.Quantity number units) -> List.List (Quantity.Quantity number units)"},{"name":"sqrt","comment":" Take a quantity in `Squared units` and return the square root of that\nquantity in plain `units`:\n\n    Quantity.sqrt (Area.hectares 1)\n    --> Length.meters 100\n\nGetting fancier, you could write a 2D hypotenuse (magnitude) function that\nworked on _any_ quantity type (length, speed, force...) as\n\n    hypotenuse :\n        Quantity Float units\n        -> Quantity Float units\n        -> Quantity Float units\n    hypotenuse x y =\n        Quantity.sqrt <|\n            Quantity.sum\n                [ Quantity.squared x\n                , Quantity.squared y\n                ]\n\nThis works because:\n\n  - The `x` and `y` arguments are both in `units`\n  - So each list item is in `Squared units`\n  - So the sum is also in `Squared units`\n  - And calling `sqrt` on something in `Squared units` returns a value back in\n    `units`\n\n","type":"Quantity.Quantity Basics.Float (Quantity.Squared units) -> Quantity.Quantity Basics.Float units"},{"name":"squared","comment":" Square a quantity with some `units`, resulting in a new quantity in\n`Squared units`:\n\n    Quantity.squared (Length.meters 5)\n    --> Area.squareMeters 25\n\n(See the documentation of [`product`](#product) for an explanation of why a\nsquared `Length` does in fact give you an `Area`.)\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Squared units)"},{"name":"sum","comment":" Find the sum of a list of quanties.\n\n    Quantity.sum\n        [ Length.meters 1\n        , Length.centimeters 2\n        , Length.millimeters 3\n        ]\n    --> Length.meters 1.023\n\n    Quantity.sum []\n    --> Quantity.zero\n\n","type":"List.List (Quantity.Quantity number units) -> Quantity.Quantity number units"},{"name":"times","comment":" Multiply a rate of change by an independent quantity (the denominator in\nthe rate) to get a total value:\n\n    -- Pressure is force per area\n    pressure =\n        Pressure.kilopascals 10\n\n    area =\n        Area.squareMeters 3\n\n    pressure |> Quantity.times area\n    --> Force.newtons 30000\n\nNote that there are [other forms of multiplication](/#multiplication)!\n\n","type":"Quantity.Quantity number independentUnits -> Quantity.Quantity number (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity number dependentUnits"},{"name":"toFloat","comment":" Convert a `Quantity Float Unitless` value into a plain `Float`.\n\nIf you're looking for a function to convert a `Quantity Int units` to `Quantity\nFloat units`, check out [`toFloatQuantity`](#toFloatQuantity).\n\n","type":"Quantity.Quantity Basics.Float Quantity.Unitless -> Basics.Float"},{"name":"toFloatQuantity","comment":" Convert a `Quantity Int units` to a `Quantity Float units` with the same\nvalue. Useful when you have an `Int`-valued quantity and want to divide it by\nsomething, multiply it by a fractional value etc.\n","type":"Quantity.Quantity Basics.Int units -> Quantity.Quantity Basics.Float units"},{"name":"toInt","comment":" Convert a `Quantity Int Unitless` value into a plain `Int`.\n","type":"Quantity.Quantity Basics.Int Quantity.Unitless -> Basics.Int"},{"name":"truncate","comment":" Round a `Float`-valued quantity towards zero.\n\n    Quantity.truncate (Pixels.pixels -2.8)\n    --> Pixels.pixels -2\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Int units"},{"name":"zero","comment":" A generic zero value. This can be treated as either an `Int` or `Float`\nquantity in any units type, similar to how `Nothing` can be treated as any kind\nof `Maybe` type and `[]` can be treated as any kind of `List`.\n","type":"Quantity.Quantity number units"}],"binops":[]},{"name":"Units.Resistance","comment":" A `Resistance` value represents an electrical resistance in ohms.\n\nNote that since `Ohms` is defined as `Rate Volts Amperes` (voltage per unit\ncurrent), you can construct a `Resistance` value using `Quantity.per`:\n\n    resistance =\n        voltage |> Quantity.per current\n\nYou can also do rate-related calculations with `Resistance` values to compute\n`Voltage` or `Current`:\n\n    voltage =\n        resistance |> Quantity.times current\n\n    alsoVoltage =\n        current |> Quantity.at resistance\n\n    current =\n        voltage |> Quantity.at_ resistance\n\n@docs Resistance, Ohms\n\n@docs ohms, inOhms\n\n","unions":[],"aliases":[{"name":"Ohms","comment":" ","args":[],"type":"Resistance.Ohms"},{"name":"Resistance","comment":" ","args":[],"type":"Resistance.Resistance"}],"values":[{"name":"inOhms","comment":" Convert a resistance to a number of ohms.\n","type":"Resistance.Resistance -> Basics.Float"},{"name":"ohms","comment":" Construct a resistance from a number of ohms.\n","type":"Basics.Float -> Resistance.Resistance"}],"binops":[]},{"name":"Units.Speed","comment":" A `Speed` value represents a speed in meters per second, miles per hour etc.\nIt is stored as a number of meters per second.\n\nNote that since `MetersPerSecond` is defined as `Rate Meters Seconds` (length\nper unit time), you can construct a `Speed` value using `Quantity.per`:\n\n    speed =\n        length |> Quantity.per duration\n\nYou can also do rate-related calculations with `Speed` values to compute\n`Length` or `Duration`:\n\n    length =\n        speed |> Quantity.times duration\n\n    alsoLength =\n        duration |> Quantity.at speed\n\n    duration =\n        length |> Quantity.at_ speed\n\n@docs Speed, MetersPerSecond\n\n@docs metersPerSecond, inMetersPerSecond, feetPerSecond, inFeetPerSecond\n@docs kilometersPerHour, inKilometersPerHour, milesPerHour, inMilesPerHour\n\n","unions":[],"aliases":[{"name":"MetersPerSecond","comment":" ","args":[],"type":"Speed.MetersPerSecond"},{"name":"Speed","comment":" ","args":[],"type":"Speed.Speed"}],"values":[{"name":"feetPerSecond","comment":" Construct a speed from a number of feet per second.\n","type":"Basics.Float -> Speed.Speed"},{"name":"inFeetPerSecond","comment":" Convert a speed to a number of feet per second.\n","type":"Speed.Speed -> Basics.Float"},{"name":"inKilometersPerHour","comment":" Convert a speed to a number of kilometers per hour.\n","type":"Speed.Speed -> Basics.Float"},{"name":"inMetersPerSecond","comment":" Convert a speed to a number of meters per second.\n","type":"Speed.Speed -> Basics.Float"},{"name":"inMilesPerHour","comment":" Convert a speed to a number of miles per hour.\n","type":"Speed.Speed -> Basics.Float"},{"name":"kilometersPerHour","comment":" Construct a speed from a number of kilometers per hour.\n","type":"Basics.Float -> Speed.Speed"},{"name":"metersPerSecond","comment":" Construct a speed from a number of meters per second.\n","type":"Basics.Float -> Speed.Speed"},{"name":"milesPerHour","comment":" Construct a speed from a number of miles per hour.\n","type":"Basics.Float -> Speed.Speed"}],"binops":[]},{"name":"Units.Temperature","comment":" Unlike other modules in `elm-units`, this module contains two different\nprimary types:\n\n  - `Temperature`, which is not actually a `Quantity` since temperatures don't\n    really act like normal quantities. For example, it doesn't make sense to\n    add two temperatures or find the ratio between them.\n  - `Delta`, which represents the difference between two temperatures. A `Delta`\n    _is_ a `Quantity` since it does make sense to add two deltas to get a net\n    delta, find the ratio between two deltas (one rise in temperature might be\n    twice as much as another rise in temperature), etc.\n\nSince a `Temperature` value is not a `Quantity`, this module exposes specialized\nfunctions for doing the operations on `Temperature` values that _do_ make sense,\nsuch as comparing two temperatures or sorting a list of temperatures. It's also\npossible to find the delta from one temperature to another using [`minus`](Temperature#minus),\nand then add a `Delta` to a `Temperature` using [`plus`](Temperature#plus).\n\n@docs Temperature, Delta, CelsiusDegrees\n\n\n# Temperatures\n\n@docs degreesCelsius, inDegreesCelsius, degreesFahrenheit, inDegreesFahrenheit, kelvins, inKelvins, absoluteZero\n\n\n# Deltas\n\nFollowing the suggestion mentioned [here](https://en.wikipedia.org/wiki/Celsius#Temperatures_and_intervals),\nthis module uses (for example) `celsiusDegrees` to indicate a temperature delta\n(change in temperature), in contrast to `degreesCelsius` which indicates an\nactual temperature.\n\n@docs celsiusDegrees, inCelsiusDegrees, fahrenheitDegrees, inFahrenheitDegrees\n\n\n# Comparison\n\n@docs lessThan, greaterThan, compare, equalWithin, min, max\n\n\n# Arithmetic\n\n@docs plus, minus, clamp\n\n\n# List functions\n\n@docs minimum, maximum, sort\n\n","unions":[],"aliases":[{"name":"CelsiusDegrees","comment":" Tempereature deltas are stored as a number of Celsius degrees.\n","args":[],"type":"Temperature.CelsiusDegrees"},{"name":"Delta","comment":" A `Delta` represents the difference between two temperatures.\n","args":[],"type":"Temperature.Delta"},{"name":"Temperature","comment":" A temperature such as 25 degrees Celsius or 80 degrees Fahrenheit.\n","args":[],"type":"Temperature.Temperature"}],"values":[{"name":"absoluteZero","comment":" [Absolute zero](https://en.wikipedia.org/wiki/Absolute_zero), equal to zero\nkelvins or -273.15 degrees Celsius.\n\n    Temperature.absoluteZero\n    --> Temperature.degreesCelsius -273.15\n\n","type":"Temperature.Temperature"},{"name":"celsiusDegrees","comment":" Construct a temperature delta from a number of Celsius degrees.\n","type":"Basics.Float -> Temperature.Delta"},{"name":"clamp","comment":" Given a lower and upper bound, clamp a given temperature to within those\nbounds. Say you wanted to clamp a temperature to be between 18 and 22 degrees\nCelsius:\n\n    lowerBound =\n        Temperature.degreesCelsius 18\n\n    upperBound =\n        Temperature.degreesCelsius 22\n\n    Temperature.degreesCelsius 25\n        |> Temperature.clamp lowerBound upperBound\n    --> Temperature.degreesCelsius 22\n\n    Temperature.degreesFahrenheit 67 -- approx 19.4 °C\n        |> Temperature.clamp lowerBound upperBound\n    --> Temperature.degreesFahrenheit 67\n\n    Temperature.absoluteZero\n        |> Temperature.clamp lowerBound upperBound\n    --> Temperature.degreesCelsius 18\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"compare","comment":" Compare two temperatures, returning an [`Order`](https://package.elm-lang.org/packages/elm/core/latest/Basics#Order)\nvalue indicating whether the first is less than, equal to or greater than the\nsecond.\n\n    Temperature.compare\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 75)\n    --> GT\n\n    Temperature.compare\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 77)\n    --> EQ\n\n(Note that due to floating-point roundoff, you generally shouldn't rely on\ntemperatures comparing as exactly equal.)\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Order"},{"name":"degreesCelsius","comment":" Construct a temperature from a number of degrees Celsius.\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"degreesFahrenheit","comment":" Construct a temperature from a number of degrees Fahrenheit.\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"equalWithin","comment":" Check if two temperatures are equal within a given delta tolerance. The\ntolerance must be greater than or equal to zero - if it is negative, then the\nresult will always be false.\n\n    Temperature.equalWithin (Temperature.fahrenheitDegrees 1)\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 75)\n    --> False\n\n    Temperature.equalWithin (Temperature.fahrenheitDegrees 3)\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 75)\n    --> True\n\n","type":"Temperature.Delta -> Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"fahrenheitDegrees","comment":" Construct a temperature delta from a number of Fahrenheit degrees.\n\n    Temperature.fahrenheitDegrees 36\n    --> Temperature.celsiusDegrees 20\n\n","type":"Basics.Float -> Temperature.Delta"},{"name":"greaterThan","comment":" Check if one temperature is less than another. Note the [argument order](/#argument-order)!\n\n    roomTemperature =\n        Temperature.degreesCelsius 21\n\n    Temperature.degreesFahrenheit 50\n        |> Temperature.greaterThan roomTemperature\n    --> False\n\n    -- Same as:\n    Temperature.greaterThan roomTemperature\n        (Temperature.degreesFahrenheit 50)\n    --> False\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"inCelsiusDegrees","comment":" Convert a temperature delta to a number of Celsius degrees.\n","type":"Temperature.Delta -> Basics.Float"},{"name":"inDegreesCelsius","comment":" Convert a temperature to a number of degrees Celsius.\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"inDegreesFahrenheit","comment":" Convert a temperature to a number of degrees Fahrenheit.\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"inFahrenheitDegrees","comment":" Convert a temperature delta to a number of Fahrenheit degrees.\n\n    Temperature.celsiusDegrees 10\n        |> Temperature.inFahrenheitDegrees\n    --> 18\n\n","type":"Temperature.Delta -> Basics.Float"},{"name":"inKelvins","comment":" Convert a temperature to a number of kelvins.\n\n    Temperature.degreesCelsius 0\n        |> Temperature.inKelvins\n    --> 273.15\n\n","type":"Temperature.Temperature -> Basics.Float"},{"name":"kelvins","comment":" Construct a temperature from a number of [kelvins][kelvin].\n\n    Temperature.kelvins 300\n    --> Temperature.degreesCelsius 26.85\n\n[kelvin]: https://en.wikipedia.org/wiki/Kelvin \"Kelvin\"\n\n","type":"Basics.Float -> Temperature.Temperature"},{"name":"lessThan","comment":" Check if one temperature is less than another. Note the [argument order](/#argument-order)!\n\n    roomTemperature =\n        Temperature.degreesCelsius 21\n\n    Temperature.degreesFahrenheit 50\n        |> Temperature.lessThan roomTemperature\n    --> True\n\n    -- Same as:\n    Temperature.lessThan roomTemperature\n        (Temperature.degreesFahrenheit 50)\n    --> True\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Basics.Bool"},{"name":"max","comment":" Find the maximum of two temperatures.\n\n    Temperature.max\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 75)\n    --> Temperature.degreesCelsius 25\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"maximum","comment":" Find the maximum of a list of temperatures. Returns `Nothing` if the list\nis empty.\n\n    Temperature.maximum\n        [ Temperature.degreesCelsius 20\n        , Temperature.kelvins 300\n        , Temperature.degreesFahrenheit 74\n        ]\n    --> Just (Temperature.kelvins 300)\n\n","type":"List.List Temperature.Temperature -> Maybe.Maybe Temperature.Temperature"},{"name":"min","comment":" Find the minimum of two temperatures.\n\n    Temperature.min\n        (Temperature.degreesCelsius 25)\n        (Temperature.degreesFahrenheit 75)\n    --> Temperature.degreesFahrenheit 75\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Temperature"},{"name":"minimum","comment":" Find the minimum of a list of temperatures. Returns `Nothing` if the list\nis empty.\n\n    Temperature.minimum\n        [ Temperature.degreesCelsius 20\n        , Temperature.kelvins 300\n        , Temperature.degreesFahrenheit 74\n        ]\n    --> Just (Temperature.degreesCelsius 20)\n\n","type":"List.List Temperature.Temperature -> Maybe.Maybe Temperature.Temperature"},{"name":"minus","comment":" Subtract one `Temperature` from another to get a `Delta`. Note the [argument\norder](/#argument-order)!\n\n    -- 25 degrees Celsius is 77 degrees Fahrenheit\n    start =\n        Temperature.celsius 25\n\n    end =\n        Temperature.fahrenheit 80\n\n    end |> Temperature.minus start\n    --> Temperature.fahrenheitDegrees 3\n\n    start |> Temperature.minus end\n    --> Temperature.fahrenheitDegrees -3\n\n","type":"Temperature.Temperature -> Temperature.Temperature -> Temperature.Delta"},{"name":"plus","comment":" Add a `Delta` to a `Temperature` to get a new `Temperature`.\n\n    Temperature.degreesCelsius 25\n        |> Temperature.plus\n            (Temperature.celsiusDegrees 7)\n    --> Temperature.degreesCelsius 32\n\nIf you want to _subtract_ a `Delta` from a `Temperature`, you can [`negate`](Quantity#negate)\nthe delta first and then call `plus`.\n\n","type":"Temperature.Delta -> Temperature.Temperature -> Temperature.Temperature"},{"name":"sort","comment":" Sort a list of temperatures from lowest to highest.\n\n    Temperature.sort\n        [ Temperature.degreesCelsius 20\n        , Temperature.kelvins 300\n        , Temperature.degreesFahrenheit 74\n        ]\n    --> [ Temperature.degreesCelsius 20\n    --> , Temperature.degreesFahrenheit 74\n    --> , Temperature.kelvins 300\n    --> ]\n\n","type":"List.List Temperature.Temperature -> List.List Temperature.Temperature"}],"binops":[]},{"name":"Units.Voltage","comment":" A `Voltage` value represents a voltage (electric potential difference, if\nwe're being picky) in volts.\n\nNote that since `Volts` is defined as `Rate Watts Amperes` (power per unit\ncurrent), you can do rate-related calculations with `Voltage` values to compute\n`Power` or `Current`:\n\n    -- elm-units version of 'P = V * I'\n    power =\n        voltage |> Quantity.times current\n\n    alsoPower =\n        current |> Quantity.at voltage\n\n    current =\n        power |> Quantity.at_ voltage\n\nJust for fun, note that since you can also [express `Voltage` in terms of\n`Current` and `Resistance`](Resistance), you could rewrite the second example\nabove as\n\n    -- P = I^2 * R\n    power =\n        current\n            |> Quantity.at\n                (current\n                    |> Quantity.at resistance\n                )\n\n@docs Voltage, Volts\n\n@docs volts, inVolts\n\n","unions":[],"aliases":[{"name":"Voltage","comment":" ","args":[],"type":"Voltage.Voltage"},{"name":"Volts","comment":" ","args":[],"type":"Voltage.Volts"}],"values":[{"name":"inVolts","comment":" Convert a voltage to a number of volts.\n","type":"Voltage.Voltage -> Basics.Float"},{"name":"volts","comment":" Construct a voltage from a number of volts.\n","type":"Basics.Float -> Voltage.Voltage"}],"binops":[]}]