[{"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.for 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.AngularAcceleration","comment":" An `AngularAcceleration` represents an angular acceleration in radians per\nsecond squared, degrees per second squared, and turns per second squared. It is\nstored as a number of radians per second squared.\n\nNote that since `RadiansPerSecondSquared` is defined as `Rate RadiansPerSecond\nSeconds` (change in angular speed per unit time), you can construct an\n`AngularAcceleration` value using `Quantity.per`:\n\n    angularAcceleration =\n        changeInAngularSpeed |> Quantity.per duration\n\nYou can also do rate-related calculations with `AngularAcceleration` values to\ncompute `AngularSpeed` or `Duration`:\n\n    changeInAngularSpeed =\n        angularAcceleration |> Quantity.for duration\n\n    alsoChangeInAngularSpeed =\n        duration |> Quantity.at angularAcceleration\n\n    duration =\n        changeInAngularSpeed |> Quantity.at_ angularAcceleration\n\n@docs AngularAcceleration, RadiansPerSecondSquared\n\n@docs radiansPerSecondSquared, inRadiansPerSecondSquared, degreesPerSecondSquared, inDegreesPerSecondSquared\n@docs turnsPerSecondSquared, inTurnsPerSecondSquared\n\n","unions":[],"aliases":[{"name":"AngularAcceleration","comment":" ","args":[],"type":"AngularAcceleration.AngularAcceleration"},{"name":"RadiansPerSecondSquared","comment":" ","args":[],"type":"AngularAcceleration.RadiansPerSecondSquared"}],"values":[{"name":"degreesPerSecondSquared","comment":" Construct an angular acceleration from a number of degrees per second squared.\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"},{"name":"inDegreesPerSecondSquared","comment":" Convert an angular acceleration to a number of degrees per second squared.\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"inRadiansPerSecondSquared","comment":" Convert an angular acceleration to a number of radians per second squared.\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"inTurnsPerSecondSquared","comment":" Convert an angular acceleration to a number of turns per second squared.\n","type":"AngularAcceleration.AngularAcceleration -> Basics.Float"},{"name":"radiansPerSecondSquared","comment":" Construct an angular acceleration from a number of radians per second squared.\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"},{"name":"turnsPerSecondSquared","comment":" Construct an angular acceleration from a number of turns per second squared.\n","type":"Basics.Float -> AngularAcceleration.AngularAcceleration"}],"binops":[]},{"name":"Units.AngularSpeed","comment":" An `AngularSpeed` represents an acceleration in radians per second, degrees\nper second, turns (revolutions) per second and turns (revolutions) per minute.\nIt is stored as a number of radians per second.\n\nNote that since `RadiansPerSecond` is defined as `Rate Radians Seconds` (angle\nper unit time), you can construct an `AngularSpeed` value using `Quantity.per`:\n\n    angularSpeed =\n        angle |> Quantity.per duration\n\nYou can also do rate-related calculations with `AngularSpeed` values to compute\n`Angle` or `Duration`:\n\n    angle =\n        angularSpeed |> Quantity.for duration\n\n    alsoAngle =\n        duration |> Quantity.at angularSpeed\n\n    duration =\n        angle |> Quantity.at_ angularSpeed\n\n@docs AngularSpeed, RadiansPerSecond\n\n@docs radiansPerSecond, inRadiansPerSecond, degreesPerSecond, inDegreesPerSecond\n@docs turnsPerSecond, inTurnsPerSecond, turnsPerMinute, inTurnsPerMinute\n\n\n## Aliases for `turns` as `revolutions`\n\nThe Elm core `Basics` module uses `turns` in its [Angle Conversions](https://package.elm-lang.org/packages/elm-lang/core/latest/Basics#angle-conversions).\nTo be consistent, this module also uses `turns`, however since 'revolutions per\nminute' (RPM) is in common usage, several aliases are provided.\n\n@docs revolutionsPerSecond, inRevolutionsPerSecond, revolutionsPerMinute, inRevolutionsPerMinute\n\n","unions":[],"aliases":[{"name":"AngularSpeed","comment":" ","args":[],"type":"AngularSpeed.AngularSpeed"},{"name":"RadiansPerSecond","comment":" ","args":[],"type":"AngularSpeed.RadiansPerSecond"}],"values":[{"name":"degreesPerSecond","comment":" Construct an angular speed from a number of degrees per second.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"inDegreesPerSecond","comment":" Convert an angular speed to a number of degrees per second.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRadiansPerSecond","comment":" Convert an angular speed to a number of radians per second.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRevolutionsPerMinute","comment":" Alias for `inTurnsPerMinute`.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inRevolutionsPerSecond","comment":" Alias for `inTurnsPerSecond`.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inTurnsPerMinute","comment":" Convert an angular speed to a number of turns per minute.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"inTurnsPerSecond","comment":" Convert an angular speed to a number of turns per second.\n","type":"AngularSpeed.AngularSpeed -> Basics.Float"},{"name":"radiansPerSecond","comment":" Construct an angular speed from a number of radians per second.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"revolutionsPerMinute","comment":" Alias for `turnsPerMinute`.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"revolutionsPerSecond","comment":" Alias for `turnsPerSecond`.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"turnsPerMinute","comment":" Construct an angular speed from a number of turns per minute.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"},{"name":"turnsPerSecond","comment":" Construct an angular speed from a number of turns per second.\n","type":"Basics.Float -> AngularSpeed.AngularSpeed"}],"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.times`](Quantity#times) 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    Length.feet 25 |> Quantity.times (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.Capacitance","comment":" A `Capacitance` value represents an electrical capacitance in farads.\n\nNote that since `Capacitance` is defined as `Rate Coulombs Volts` (charge per\nvoltage), you can construct a `Capacitance` value using `Quantity.per`:\n\n    capacitance =\n        charge |> Quantity.per voltage\n\nYou can also compute `Charge` and `Voltage` using `Capacitance`:\n\n    charge =\n        voltage |> Quantity.at capacitance\n\n    voltage =\n        charge |> Quantity.at_ capacitance\n\n@docs Capacitance, Farads\n\n@docs farads, inFarads\n@docs picofarads, inPicofarads, nanofarads, inNanofarads, microfarads, inMicrofarads\n\n","unions":[],"aliases":[{"name":"Capacitance","comment":" ","args":[],"type":"Capacitance.Capacitance"},{"name":"Farads","comment":" ","args":[],"type":"Capacitance.Farads"}],"values":[{"name":"farads","comment":" Construct capacitance from a number of farads.\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"inFarads","comment":" Convert capacitance to a number of farads.\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inMicrofarads","comment":" Convert a capacitance to a number of microfarads\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inNanofarads","comment":" Convert a capacitance to a number of nanofarads\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"inPicofarads","comment":" Convert a capacitance to a number of picofarads.\n","type":"Capacitance.Capacitance -> Basics.Float"},{"name":"microfarads","comment":" Construct a capacitance from a number of microfarads.\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"nanofarads","comment":" Construct a capacitance from a number of nanofarads\n","type":"Basics.Float -> Capacitance.Capacitance"},{"name":"picofarads","comment":" Construct capacitance from a number of picofarads.\n","type":"Basics.Float -> Capacitance.Capacitance"}],"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.for 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.Density","comment":" A `Density` value represents a density in grams per cubic centimeter, pounds\nper cubic inch, etc. It is stored as a number of kilograms per cubic meter.\n\nNote that since `KilogramsPerCubicMeter` is defined as `Rate Kilograms\nCubicMeters` (mass per unit volume), you can construct a `Density` value using\n`Quantity.per`:\n\n    density =\n        mass |> Quantity.per volume\n\nYou can also do rate-related calculations with `Density` values to compute\n`Mass` or `Volume`:\n\n    mass =\n        volume |> Quantity.at density\n\n    volume =\n        mass |> Quantity.at_ density\n\n@docs Density, KilogramsPerCubicMeter\n\n\n## Metric\n\n@docs kilogramsPerCubicMeter, inKilogramsPerCubicMeter, gramsPerCubicCentimeter, inGramsPerCubicCentimeter\n\n\n## Imperial\n\n@docs poundsPerCubicInch, inPoundsPerCubicInch, poundsPerCubicFoot, inPoundsPerCubicFoot\n\n","unions":[],"aliases":[{"name":"Density","comment":" ","args":[],"type":"Density.Density"},{"name":"KilogramsPerCubicMeter","comment":" ","args":[],"type":"Density.KilogramsPerCubicMeter"}],"values":[{"name":"gramsPerCubicCentimeter","comment":" Construct a density from a number of grams per cubic centimeter.\n","type":"Basics.Float -> Density.Density"},{"name":"inGramsPerCubicCentimeter","comment":" Convert a density to a number of grams per cubic centimeter.\n","type":"Density.Density -> Basics.Float"},{"name":"inKilogramsPerCubicMeter","comment":" Convert a density to a number of kilograms per cubic meter.\n","type":"Density.Density -> Basics.Float"},{"name":"inPoundsPerCubicFoot","comment":" Convert a density to a number of pounds per cubic foot.\n","type":"Density.Density -> Basics.Float"},{"name":"inPoundsPerCubicInch","comment":" Convert a density to a number of pounds per cubic inch.\n","type":"Density.Density -> Basics.Float"},{"name":"kilogramsPerCubicMeter","comment":" Construct a density from a number of kilograms per cubic meter.\n","type":"Basics.Float -> Density.Density"},{"name":"poundsPerCubicFoot","comment":" Construct a density from a number of pounds per cubic foot.\n","type":"Basics.Float -> Density.Density"},{"name":"poundsPerCubicInch","comment":" Construct a density from a number of pounds per cubic inch.\n","type":"Basics.Float -> Density.Density"}],"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`](https://package.elm-lang.org/packages/elm/time/latest/Time#Posix)\nvalues 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\nNote that since `Joules` is defined as `Product Newtons Meters`, you can compute\nenergy directly as a product of force and distance:\n\n    Force.newtons 5 |> Quantity.times (Length.meters 4)\n    --> Energy.joules 20\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 `Product Kilograms\nMetersPerSecondSquared`, you can compute force directly as a product of mass and\nacceleration:\n\n    mass =\n        Mass.kilograms 10\n\n    acceleration =\n        Acceleration.metersPerSecondSquared 2\n\n    mass |> Quantity.times acceleration\n    --> Force.newtons 20\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.Inductance","comment":" A `Inductance` value represents an electrical inductance in henries.\n\n@docs Inductance, Henries\n@docs henries, inHenries\n@docs nanohenries, inNanohenries, microhenries, inMicrohenries, millihenries, inMillihenries, kilohenries, inKilohenries\n\n","unions":[],"aliases":[{"name":"Henries","comment":" ","args":[],"type":"Inductance.Henries"},{"name":"Inductance","comment":" ","args":[],"type":"Inductance.Inductance"}],"values":[{"name":"henries","comment":" Construct an inductance from a number of henries.\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"inHenries","comment":" Convert an inductance to a number of henries.\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inKilohenries","comment":" Convert an inductance to a number of kilohenries.\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inMicrohenries","comment":" Convert an inductance to a number of microhenries.\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inMillihenries","comment":" Convert an inductance to a number of millihenries.\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"inNanohenries","comment":" Convert an inductance to a number of nanohenries.\n","type":"Inductance.Inductance -> Basics.Float"},{"name":"kilohenries","comment":" Construct an inductance from a number of kilohenries.\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"microhenries","comment":" Construct an inductance from a number of microhenries.\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"millihenries","comment":" Construct an inductance from a number of millihenries.\n","type":"Basics.Float -> Inductance.Inductance"},{"name":"nanohenries","comment":" Construct an inductance from a number of nanohenries.\n","type":"Basics.Float -> Inductance.Inductance"}],"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    area =\n        pixels 1920 |> Quantity.times (pixels 1080)\n\n    area |> 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.for 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        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`, `Cubed`, `Product` and `Rate` units types allow you to build up\nand work with composite units in a fairly flexible way.\n\n@docs Squared, Cubed, Product, Rate\n\n\n# Constants\n\n@docs zero, infinity, positiveInfinity, negativeInfinity\n\n\n# Comparison\n\n@docs lessThan, greaterThan, lessThanOrEqualTo, greaterThanOrEqualTo, compare, equalWithin, max, min, isNaN, isInfinite\n\n\n# Arithmetic\n\n@docs negate, abs, plus, minus, multiplyBy, divideBy, squared, sqrt, cubed, cbrt\n\n\n## Working with products\n\n@docs times, over, over_\n\n\n## Working with rates\n\n@docs per, at, at_, for, inverse\n\n\n## Miscellaneous\n\n@docs ratio, clamp, interpolateFrom, midpoint, range\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, sortBy\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":"Cubed","comment":" Represents a units type that is the cube of some other units type; for\nexample, `Meters` is one units type (the units type of a [`Length`](Length)) and\n`Cubed Meters` is another (the units type of an [`Volume`](Volume)). See the\n[`cubed`](Quantity#cubed) and [`cbrt`](Quantity#cbrt) functions for examples of\nuse.\n\nThis is a special case of the `Product` units type.\n\n","args":["units"],"type":"Quantity.Cubed units"},{"name":"Product","comment":" Represents a units type that is the product of two other units types. This\nis a more general form of `Squared` or `Cubed`. See [`times`](#product),\n[`over`](#over) and [`over_`](#over_) for how it can be used.\n","args":["units1","units2"],"type":"Quantity.Product units1 units2"},{"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`). See [Working with\nrates](#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`](Length)) and\n`Squared Meters` is another (the units type of an [`Area`](Area)). See the\n[`squared`](#squared) and [`sqrt`](#sqrt) functions for examples of use.\n\nThis is a special case of the `Product` units type.\n\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":" Multiply a rate of change by an independent quantity (the denominator in\nthe rate) to get a total value:\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\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\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_ quantity (total value), determine the\nnecessary amount of the _independent_ quantity:\n\n    Length.kilometers 75\n        |> Quantity.at_\n            (Speed.kilometersPerHour 100)\n    --> Duration.minutes 45\n\nWhere `at` performs multiplication, `at_` performs division - you multiply a\nspeed by a duration to get a distance, but you divide a distance by a speed to\nget 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":"cbrt","comment":" Take a quantity in `Cubed units` and return the cube root of that\nquantity in plain `units`.\n\n    Quantity.cbrt (Volume.liters 1)\n    --> Length.centimeters 10\n\n","type":"Quantity.Quantity Basics.Float (Quantity.Cubed units) -> Quantity.Quantity Basics.Float units"},{"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":"cubed","comment":" Cube a quantity with some `units`, resulting in a new quantity in\n`Cubed units`.\n\n    Quantity.cubed (Length.meters 5)\n    --> Volume.cubicMeters 125\n\n","type":"Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Cubed units)"},{"name":"divideBy","comment":" Divide a `Quantity` by a `Float`.\n\n    Quantity.divideBy 2 (Duration.hours 1)\n    --> Duration.minutes 30\n\nNote that there are [other forms of division](/#multiplication-and-division)!\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":"for","comment":" Same as `at` but with the argument order flipped, which may read better\nin some cases:\n\n    Speed.kilometersPerHour 100\n        |> Quantity.for\n            (Duration.minutes 30)\n    --> Length.kilometers 50\n\n","type":"Quantity.Quantity number independentUnits -> Quantity.Quantity number (Quantity.Rate dependentUnits independentUnits) -> Quantity.Quantity number dependentUnits"},{"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":"greaterThanOrEqualTo","comment":" Check if one quantity is greater than or equal to another. Note the\n[argument order](/#argument-order)!\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":"interpolateFrom","comment":" Interpolate from the first quantity to the second, based on a parameter that\nranges from zero to one. Passing a parameter value of zero will return the start\nvalue and passing a parameter value of one will return the end value.\n\n    fiveMeters =\n        Length.meters 5\n\n    tenMeters =\n        Length.meters 10\n\n    Quantity.interpolateFrom fiveMeters tenMeters 0\n    --> Length.meters 5\n\n    Quantity.interpolateFrom fiveMeters tenMeters 1\n    --> Length.meters 10\n\n    Quantity.interpolateFrom fiveMeters tenMeters 0.6\n    --> Length.meters 8\n\nThe end value can be less than the start value:\n\n    Quantity.interpolateFrom tenMeters fiveMeters 0.1\n    --> Length.meters 9.5\n\nParameter values less than zero or greater than one can be used to extrapolate:\n\n    Quantity.interpolateFrom fiveMeters tenMeters 1.5\n    --> Length.meters 12.5\n\n    Quantity.interpolateFrom fiveMeters tenMeters -0.5\n    --> Length.meters 2.5\n\n    Quantity.interpolateFrom tenMeters fiveMeters -0.2\n    --> Length.meters 11\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Basics.Float -> Quantity.Quantity Basics.Float units"},{"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":"lessThanOrEqualTo","comment":" Check if one quantity is less than or equal to another. Note the [argument\norder](/#argument-order)!\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":"midpoint","comment":" Find the midpoint between two quantities.\n\n    Quantity.midpoint (Length.meters 5) (Length.meters 10)\n    --> Length.meters 7.5\n\n","type":"Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float units -> Quantity.Quantity Basics.Float 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":"multiplyBy","comment":" Scale a `Quantity` by a `number`.\n\n    Quantity.multiplyBy 1.5 (Duration.hours 1)\n    --> Duration.minutes 90\n\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\n\n","type":"number -> 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":"over","comment":" Divide a quantity in `Product units1 units2` by a quantity in `units1`,\nresulting in another quantity in `units2`. For example, the units type of a\n`Force` is `Product Kilograms MetersPerSecondSquared` (mass times acceleration),\nso we could divide a force by a given mass to determine how fast that mass would\nbe accelerated by the given force:\n\n    Force.newtons 100\n        |> Quantity.over\n            (Mass.kilograms 50)\n    --> Acceleration.metersPerSecondSquared 2\n\nNote that there are [other forms of division](/#multiplication-and-division)!\n\n","type":"Quantity.Quantity Basics.Float units1 -> Quantity.Quantity Basics.Float (Quantity.Product units1 units2) -> Quantity.Quantity Basics.Float units2"},{"name":"over_","comment":" Just like `over` but divide by a quantity in `units2`, resulting in another\nquantity in `units1`. For example, we could divide a force by a desired\nacceleration to determine how much mass could be accelerated at that rate:\n\n    Force.newtons 100\n        |> Quantity.over_\n            (Acceleration.metersPerSecondSquared 5)\n    --> Mass.kilograms 20\n\n","type":"Quantity.Quantity Basics.Float units2 -> Quantity.Quantity Basics.Float (Quantity.Product units1 units2) -> Quantity.Quantity Basics.Float units1"},{"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  - `Current` is `Charge` per `Duration`\n  - `Resistance` is `Voltage` per `Current`\n  - `Voltage` is `Power` per `Current`\n\nNote that there are [other forms of division](/#multiplication-and-division)!\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":"range","comment":" Construct a range of evenly-spaced values given a `start` value, an `end`\nvalue and the number of `steps` to take from the start to the end. The first\nvalue in the returned list will be equal to `start` and the last value will be\nequal to `end`. Note that the number of returned values will be one greater than\nthe number of steps!\n\n    Quantity.range\n        { start = Length.meters 2\n        , end = Length.meters 3\n        , steps = 5\n        }\n    --> [ Length.centimeters 200\n    --> , Length.centimeters 220\n    --> , Length.centimeters 240\n    --> , Length.centimeters 260\n    --> , Length.centimeters 280\n    --> , Length.centimeters 300\n    --> ]\n\nThe start and end values can be in either order:\n\n    Quantity.range\n        { start = Duration.hours 1\n        , end = Quantity.zero\n        , steps = 4\n        }\n    --> [ Duration.minutes 60\n    --> , Duration.minutes 45\n    --> , Duration.minutes 30\n    --> , Duration.minutes 15\n    --> , Duration.minutes 0\n    --> ]\n\nPassing a negative or zero `steps` value will result in an empty list being\nreturned.\n\nIf you need finer control over what values get generated, try combining\n`interpolateFrom` with the various functions in the\n[`elm-1d-parameter`](https://package.elm-lang.org/packages/ianmackenzie/elm-1d-parameter/latest/)\npackage. For example:\n\n    -- Same as using Quantity.range\n    Parameter1d.steps 4 <|\n        Quantity.interpolateFrom\n            (Length.meters 2)\n            (Length.meters 3)\n    --> [ Length.centimeters 200\n    --> , Length.centimeters 225\n    --> , Length.centimeters 250\n    --> , Length.centimeters 275\n    --> , Length.centimeters 300\n    --> ]\n\n    -- Omit the last value\n    Parameter1d.leading 4 <|\n        Quantity.interpolateFrom\n            (Length.meters 2)\n            (Length.meters 3)\n    --> [ Length.centimeters 200\n    --> , Length.centimeters 225\n    --> , Length.centimeters 250\n    --> , Length.centimeters 275\n    --> ]\n\n","type":"{ start : Quantity.Quantity Basics.Float units, end : Quantity.Quantity Basics.Float units, steps : Basics.Int } -> List.List (Quantity.Quantity Basics.Float 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":"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":"sortBy","comment":" Sort an arbitrary list of values by a derived `Quantity`. If you had\n\n    people =\n        [ { name = \"Bob\", height = Length.meters 1.6 }\n        , { name = \"Charlie\", height = Length.meters 2.0 }\n        , { name = \"Alice\", height = Length.meters 1.8 }\n        ]\n\nthen you could sort by name with\n\n    List.sortBy .name people\n    --> [ { name = \"Alice\", height = Length.meters 1.8 }\n    --> , { name = \"Bob\", height = Length.meters 1.6 }\n    --> , { name = \"Charlie\", height = Length.meters 2.0 }\n    --> ]\n\n(nothing new there!), and sort by height with\n\n    Quantity.sortBy .height people\n    --> [ { name = \"Bob\", height = Length.meters 1.6 }\n    --> , { name = \"Alice\", height = Length.meters 1.8 }\n    --> , { name = \"Charlie\", height = Length.meters 2.0 }\n    --> ]\n\n","type":"(a -> Quantity.Quantity number units) -> List.List a -> List.List a"},{"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.squared x\n                |> Quantity.plus\n                    (Quantity.squared y)\n            )\n\nThis works because:\n\n  - The `x` and `y` arguments are both in `units`\n  - So each squared 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","type":"Quantity.Quantity number units -> Quantity.Quantity number (Quantity.Squared units)"},{"name":"sum","comment":" Find the sum of a list of quantities.\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 two quantities with units types `units1` and `units2` together,\nresulting in a quantity with units type `Product units1 units2`. Note the\n[argument order](/#argument-order)!\n\nThis works for any two units types, but one special case is worth pointing out.\nThe units type of an [`Area`](Area) is `SquareMeters`, which is a type alias for\n`Squared Meters`, which in turn expands to `Product Meters Meters`. This means\nthat the product of two `Length`s does in fact give you an `Area`:\n\n    -- This is the definition of an acre, I kid you not 😈\n    Length.feet 66 |> Quantity.times (Length.feet 660)\n    --> Area.acres 1\n\nWe can also multiply an `Area` by a `Length` to get a `Volume`:\n\n    Area.squareMeters 1\n        |> Quantity.times\n            (Length.centimeters 1)\n    --> Volume.liters 10\n\nNote that there are [other forms of multiplication](/#multiplication-and-division)!\n\n","type":"Quantity.Quantity number units2 -> Quantity.Quantity number units1 -> Quantity.Quantity number (Quantity.Product units1 units2)"},{"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        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.for 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.SubstanceAmount","comment":" A `SubstanceAmount` value represents a substance amount in [moles][1].\n\n[1]: https://en.wikipedia.org/wiki/Mole_(unit)\n\n@docs SubstanceAmount, Moles\n@docs moles, inMoles, picomoles, inPicomoles, nanomoles, inNanomoles\n@docs micromoles, inMicromoles, millimoles, inMillimoles, kilomoles, inKilomoles\n@docs megamoles, inMegamoles, gigamoles, inGigamoles\n\n","unions":[],"aliases":[{"name":"Moles","comment":" ","args":[],"type":"SubstanceAmount.Moles"},{"name":"SubstanceAmount","comment":" ","args":[],"type":"SubstanceAmount.SubstanceAmount"}],"values":[{"name":"gigamoles","comment":" Construct a substance amount from a number of gigamoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"inGigamoles","comment":" Convert a substance amount to a number of gigamoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inKilomoles","comment":" Convert a substance amount to a number of kilomoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMegamoles","comment":" Convert a substance amount to a number of megamoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMicromoles","comment":" Convert a substance amount to a number of micromoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMillimoles","comment":" Convert a substance amount to a number of millimoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inMoles","comment":" Convert a substance amount to a number of moles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inNanomoles","comment":" Convert a substance amount to a number of nanomoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"inPicomoles","comment":" Convert a substance amount to a number of picomoles.\n","type":"SubstanceAmount.SubstanceAmount -> Basics.Float"},{"name":"kilomoles","comment":" Construct a substance amount from a number of kilomoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"megamoles","comment":" Construct a substance amount from a number of megamoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"micromoles","comment":" Construct a substance amount from a number of micromoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"millimoles","comment":" Construct a substance amount from a number of millimoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"moles","comment":" Construct a substance amount from a number of moles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"nanomoles","comment":" Construct a substance amount from a number of nanomoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"},{"name":"picomoles","comment":" Construct a substance amount from a number of picomoles.\n","type":"Basics.Float -> SubstanceAmount.SubstanceAmount"}],"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, lessThanOrEqualTo, greaterThanOrEqualTo, 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, sortBy\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 greater 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":"greaterThanOrEqualTo","comment":" Check if one temperature is greater than or equal to another. Note the\n[argument order](/#argument-order)!\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":"lessThanOrEqualTo","comment":" Check if one temperature is less than or equal to another. Note the\n[argument order](/#argument-order)!\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.degreesCelsius 25\n\n    end =\n        Temperature.degreesFahrenheit 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"},{"name":"sortBy","comment":" Sort an arbitrary list of values by a derived `Temperature`. If you had\n\n    rooms =\n        [ ( \"Lobby\", Temperature.degreesCelsius 21 )\n        , ( \"Locker room\", Temperature.degreesCelsius 17 )\n        , ( \"Rink\", Temperature.degreesCelsius -4 )\n        , ( \"Sauna\", Temperature.degreesCelsius 82 )\n        ]\n\nthen you could sort by temperature with\n\n    Temperature.sortBy Tuple.second rooms\n    --> [ ( \"Rink\", Temperature.degreesCelsius -4 )\n    --> , ( \"Locker room\", Temperature.degreesCelsius 17 )\n    --> , ( \"Lobby\", Temperature.degreesCelsius 21 )\n    --> , ( \"Sauna\", Temperature.degreesCelsius 82 )\n    --> ]\n\n","type":"(a -> Temperature.Temperature) -> List.List a -> List.List a"}],"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        current |> Quantity.at voltage\n\n    -- I = P / V\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":[]},{"name":"Units.Volume","comment":" A `Volume` represents a volume in cubic meters, cubic feet, liters, US\nliquid gallons, imperial fluid ounces etc. It is stored as a number of cubic\nmeters.\n\n@docs Volume, CubicMeters\n\n\n## Metric\n\n@docs cubicMeters, inCubicMeters\n@docs milliliters, inMilliliters, liters, inLiters\n\n\n## Imperial\n\n@docs cubicInches, inCubicInches, cubicFeet, inCubicFeet, cubicYards, inCubicYards\n@docs usLiquidGallons, inUsLiquidGallons, usDryGallons, inUsDryGallons, imperialGallons, inImperialGallons\n@docs usLiquidQuarts, inUsLiquidQuarts, usDryQuarts, inUsDryQuarts, imperialQuarts, inImperialQuarts\n@docs usLiquidPints, inUsLiquidPints, usDryPints, inUsDryPints, imperialPints, inImperialPints\n@docs usFluidOunces, inUsFluidOunces, imperialFluidOunces, inImperialFluidOunces\n\n","unions":[],"aliases":[{"name":"CubicMeters","comment":" ","args":[],"type":"Volume.CubicMeters"},{"name":"Volume","comment":" ","args":[],"type":"Volume.Volume"}],"values":[{"name":"cubicFeet","comment":" Construct a volume from a number of cubic feet.\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicInches","comment":" Construct a volume from a number of cubic inches.\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicMeters","comment":" Construct a volume from a number of cubic meters.\n","type":"Basics.Float -> Volume.Volume"},{"name":"cubicYards","comment":" Construct a volume from a number of cubic yards.\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialFluidOunces","comment":" Construct a volume from a number of imperial fluid ounces.\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialGallons","comment":" Construct a volume from a number of imperial gallons.\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialPints","comment":" Construct a volume from a number of imperial pints.\n","type":"Basics.Float -> Volume.Volume"},{"name":"imperialQuarts","comment":" Construct a volume from a number of imperial quarts.\n","type":"Basics.Float -> Volume.Volume"},{"name":"inCubicFeet","comment":" Convert a volume to a number of cubic feet.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicInches","comment":" Convert a volume to a number of cubic inches.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicMeters","comment":" Convert a volume to a number of cubic meters.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inCubicYards","comment":" Convert a volume to a number of cubic yards.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialFluidOunces","comment":" Convert a volume to a number of imperial fluid ounces.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialGallons","comment":" Convert a volume to a number of imperial gallons.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialPints","comment":" Convert a volume to a number of imperial pints.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inImperialQuarts","comment":" Convert a volume to a number of imperial quarts.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inLiters","comment":" Convert a volume to a number of liters.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inMilliliters","comment":" Convert a volume to a number of milliliters.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryGallons","comment":" Convert a volume to a number of U.S. dry gallons.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryPints","comment":" Convert a volume to a number of U.S. dry pints.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsDryQuarts","comment":" Convert a volume to a number of U.S. dry quarts.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsFluidOunces","comment":" Convert a volume to a number of U.S. fluid ounces.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidGallons","comment":" Convert a volume to a number of U.S. liquid gallons.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidPints","comment":" Convert a volume to a number of U.S. liquid pints.\n","type":"Volume.Volume -> Basics.Float"},{"name":"inUsLiquidQuarts","comment":" Convert a volume to a number of U.S. liquid quarts.\n","type":"Volume.Volume -> Basics.Float"},{"name":"liters","comment":" Construct a volume from a number of liters.\n","type":"Basics.Float -> Volume.Volume"},{"name":"milliliters","comment":" Construct a volume from a number of milliliters.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryGallons","comment":" Construct a volume from a number of U.S. dry gallons.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryPints","comment":" Construct a volume from a number of U.S. dry pints.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usDryQuarts","comment":" Construct a volume from a number of U.S. dry quarts.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usFluidOunces","comment":" Construct a volume from a number of U.S. fluid ounces.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidGallons","comment":" Construct a volume from a number of U.S. liquid gallon.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidPints","comment":" Construct a volume from a number of U.S. liquid pints.\n","type":"Basics.Float -> Volume.Volume"},{"name":"usLiquidQuarts","comment":" Construct a volume from a number of U.S. liquid quarts.\n","type":"Basics.Float -> Volume.Volume"}],"binops":[]}]